fog-azure-rm 0.0.0

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

@@ -0,0 +1,32 @@
+require "fog/core/collection"
+require "fog/azurerm/models/compute/server"
+
+module Fog
+  module Compute
+    class AzureRM
+      # This class is giving implementation of all/list, and get
+      # for Server.
+      class Servers < Fog::Collection
+        attribute :resource_group
+        model Fog::Compute::AzureRM::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)
+          end
+          load(virtual_machines)
+        end
+
+        def get(resource_group, identity)
+          all.find { |s| s.name == identity && s.resource_group == resource_group}
+        end
+
+        def get_from_remote(resource_group, name)
+          service.get_virtual_machine(resource_group, name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Fog
+  module DNS
+    class AzureRM
+      class RecordSet < Fog::Model
+        identity :name
+        attribute :resource_group
+        attribute :zone_name
+        attribute :records
+        attribute :type
+        attribute :ttl
+
+        def save
+          requires :name
+          requires :resource_group
+          requires :zone_name
+          requires :records
+          requires :type
+          requires :ttl
+          service.create_record_set(resource_group, zone_name, name, records, type, ttl)
+        end
+
+        def destroy
+          service.delete_record_set(name, resource_group, zone_name, type.split("/").last)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require "fog/core/collection"
+require "fog/azurerm/models/dns/record_set"
+
+module Fog
+  module DNS
+    class AzureRM
+      class RecordSets < Fog::Collection
+
+        attribute :resource_group
+        attribute :zone_name
+        attribute :type
+
+        model Fog::DNS::AzureRM::RecordSet
+
+        def all
+          requires :resource_group
+          requires :zone_name
+          record_sets = []
+          exclude = false
+          service.list_record_sets(resource_group, zone_name).each do |r|
+            hash = {}
+            r.each do |k, v|
+              if (k == 'name' && v == '@')
+                exclude = true
+              end
+              hash[k] = v
+              hash['zone_name'] = zone_name
+              hash['resource_group'] = resource_group
+            end
+            record_sets << hash if !exclude
+            exclude = false
+          end
+          load(record_sets)
+        end
+
+        def get(identity, type)
+          all.find { |f| f.name == identity && f.type == "Microsoft.Network/dnszones/#{type}"}
+        rescue Fog::Errors::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Fog
+  module DNS
+    class AzureRM
+      class Zone < Fog::Model
+        identity :name
+        attribute :id
+        attribute :resource_group
+
+        def save
+          requires :name
+          requires :resource_group
+          service.create_zone(resource_group, name)
+        end
+
+        def destroy
+          service.delete_zone(name, resource_group)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'fog/core/collection'
+require 'fog/azurerm/models/dns/zone'
+
+module Fog
+  module DNS
+    class AzureRM
+      class Zones < Fog::Collection
+        model Fog::DNS::AzureRM::Zone
+
+        def all
+          zones = []
+          service.list_zones.each do |z|
+            hash = {}
+            z.each do |k, v|
+              hash[k] = v
+            end
+            zones << hash
+          end
+          load(zones)
+        end
+
+        def get(identity, resource_group)
+          all.find { |f| f.name == identity && f.resource_group == resource_group }
+        rescue Fog::Errors::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Fog
+  module Network
+    class AzureRM
+      # NetworkInterface model class for Network Service
+      class NetworkInterface < Fog::Model
+        identity :name
+        attribute :location
+        attribute :resource_group
+        attribute :subnet_id
+        attribute :ip_configuration_name
+        attribute :private_ip_allocation_method
+        attribute :properties
+
+        def save
+          requires :name
+          requires :location
+          requires :resource_group
+          requires :subnet_id
+          requires :ip_configuration_name
+          requires :private_ip_allocation_method
+
+          Fog::Logger.debug "Creating Network Interface Card: #{name}..."
+          network_interface = service.create_network_interface(name, location, resource_group, subnet_id, ip_configuration_name, private_ip_allocation_method)
+          Fog::Logger.debug "Network Interface #{name} created successfully."
+          network_interface
+        end
+
+        def destroy
+          service.delete_network_interface(resource_group, name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+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
+        attribute :resource_group
+
+        def all
+          requires :resource_group
+          network_interfaces = []
+          network_interface_list = service.list_network_interfaces(resource_group)
+          network_interface_list.each do |nic|
+            hash = {}
+            nic.instance_variables.each do |var|
+              hash[var.to_s.delete('@')] = nic.instance_variable_get(var)
+            end
+            hash['resource_group'] = resource_group
+            network_interfaces << hash
+          end
+          load(network_interfaces)
+        end
+
+        def get(identity)
+          all.find { |f| f.name == identity }
+        rescue Fog::Errors::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Fog
+  module Network
+    class AzureRM
+      # PublicIP model class for Network Service
+      class PublicIp < Fog::Model
+        identity :name
+        attribute :type
+        attribute :location
+        attribute :resource_group
+
+        def save
+          requires :name
+          requires :type
+          requires :location
+          requires :resource_group
+
+          properties = Azure::ARM::Network::Models::PublicIPAddressPropertiesFormat.new
+          properties.public_ipallocation_method = type
+
+          public_ip = Azure::ARM::Network::Models::PublicIPAddress.new
+          public_ip.name = name
+          public_ip.location = location
+          public_ip.properties = properties
+
+          service.create_public_ip(resource_group, name, public_ip)
+        end
+
+        def destroy
+          service.delete_public_ip(resource_group, name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+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
+        attribute :resource_group
+
+        def all
+          requires :resource_group
+          public_ips = []
+          pubip_list = service.list_public_ips(resource_group)
+          pubip_list.each do |pip|
+            hash = {}
+            pip.instance_variables.each do |var|
+              hash[var.to_s.delete('@')] = pip.instance_variable_get(var)
+            end
+            hash['resource_group'] = resource_group
+            public_ips << hash
+          end
+          load(public_ips)
+        end
+
+        def get(identity)
+          all.find { |f| f.name == identity }
+        rescue Fog::Errors::NotFound
+          nil
+        end
+
+        def check_if_exists(resource_group, name)
+          Fog::Logger.debug "Checkng if PublicIP #{name} exists."
+          if service.check_for_public_ip(resource_group, name)
+            Fog::Logger.debug "PublicIP #{name} exists."
+            true
+          else
+            Fog::Logger.debug "PublicIP #{name} doesn't exists."
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Fog
+  module Network
+    class AzureRM
+      # Subnet model for Network Service
+      class Subnet < Fog::Model
+        identity :name
+        attribute :id
+        attribute :resource_group
+        attribute :virtual_network_name
+        attribute :properties
+        attribute :addressPrefix
+        attribute :networkSecurityGroupId
+        attribute :routeTableId
+        attribute :ipConfigurations
+
+        def save
+          requires :name
+          requires :resource_group
+          requires :virtual_network_name
+          Fog::Logger.debug "Creating Subnet: #{name}..."
+          #puts "Creating Subnet: #{name}..."
+          subnet = service.create_subnet(resource_group, virtual_network_name, name, addressPrefix)
+          Fog::Logger.debug "Subnet #{name} created successfully."
+          #puts "Subnet #{name} created successfully."
+          subnet
+        end
+
+        def destroy
+          service.delete_subnet(resource_group, virtual_network_name, name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+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
+        attribute :resource_group
+        attribute :virtual_network_name
+
+        def all
+          requires :resource_group
+          requires :virtual_network_name
+          subnets = []
+          service.list_subnets(resource_group, virtual_network_name).each do |subnet|
+            hash = {}
+            subnet.instance_variables.each do |var|
+              hash[var.to_s.delete('@')] = subnet.instance_variable_get(var)
+            end
+            hash['resource_group'] = subnet.instance_variable_get('@id').split('/')[4]
+            hash['virtual_network_name'] = subnet.instance_variable_get('@id').split('/')[8]
+            subnets << hash
+          end
+          load(subnets)
+        end
+
+        def get(identity)
+          all.find { |f| f.name == identity }
+        rescue Fog::Errors::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Fog
+  module Network
+    class AzureRM
+      class VirtualNetwork < Fog::Model
+        identity :name
+        attribute :id
+        attribute :location
+        attribute :dns_list
+        attribute :subnet_address_list
+        attribute :network_address_list
+        attribute :resource_group
+        attribute :properties
+
+        def save
+          requires :name
+          requires :location
+          requires :resource_group
+          Fog::Logger.debug "Creating Virtual Network: #{name}..."
+          virtual_network = service.create_virtual_network(name, location, resource_group, dns_list, subnet_address_list, network_address_list)
+          Fog::Logger.debug "Virtual Network #{name} created successfully."
+          virtual_network
+        end
+
+        def destroy
+          service.delete_virtual_network(resource_group, name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require 'fog/core/collection'
+require 'fog/azurerm/models/network/virtual_network'
+
+module Fog
+  module Network
+    class AzureRM
+      class VirtualNetworks < Fog::Collection
+        model Fog::Network::AzureRM::VirtualNetwork
+
+        def all
+          virtual_networks = []
+          service.list_virtual_networks.each do |vnet|
+            hash = {}
+            vnet.instance_variables.each do |var|
+              hash[var.to_s.delete('@')] = vnet.instance_variable_get(var)
+            end
+            hash['resource_group'] = vnet.instance_variable_get('@id').split('/')[4]
+            virtual_networks << hash
+          end
+          load(virtual_networks)
+        end
+
+        def get(identity, resource_group)
+          all.find { |f| f.name == identity && f.resource_group == resource_group }
+        rescue Fog::Errors::NotFound
+          nil
+        end
+
+        def check_if_exists(name, resource_group)
+          Fog::Logger.debug "Checkng if Virtual Network #{name} exists."
+          if service.check_for_virtual_network(name, resource_group)
+            Fog::Logger.debug "Virtual Network #{name} exists."
+            true
+          else
+            Fog::Logger.debug "Virtual Network #{name} doesn't exists."
+            false
+          end
+        end
+      end
+    end
+  end
+end