fog-azure-rm 0.0.1 → 0.0.2

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

@@ -0,0 +1,27 @@
+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
+        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)
+          end
+          load(network_security_groups)
+        end
+
+        def get(identity)
+          all.find { |f| f.name == identity }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Fog
+  module Network
+    class AzureRM
+      # Subnet model for Network Service
+      class NetworkSecurityRule < Fog::Model
+        identity :name
+        attribute :id
+        attribute :resource_group
+        attribute :network_security_group_name
+        attribute :description
+        attribute :protocol
+        attribute :source_port_range
+        attribute :destination_port_range
+        attribute :source_address_prefix
+        attribute :destination_address_prefix
+        attribute :access
+        attribute :priority
+        attribute :direction
+
+        def self.parse(nsr)
+          hash = {}
+          hash['id'] = nsr['id']
+          hash['name'] = nsr['name']
+          hash['resource_group'] = nsr['id'].split('/')[4]
+          hash['network_security_group_name'] = nsr['id'].split('/')[8]
+          hash['description'] = nsr['properties']['description']
+          hash['protocol'] = nsr['properties']['protocol']
+          hash['source_port_range'] = nsr['properties']['sourcePortRange']
+          hash['destination_port_range'] = nsr['properties']['destinationPortRange']
+          hash['source_address_prefix'] = nsr['properties']['sourceAddressPrefix']
+          hash['destination_address_prefix'] = nsr['properties']['destinationAddressPrefix']
+          hash['access'] = nsr['properties']['access']
+          hash['priority'] = nsr['properties']['priority']
+          hash['direction'] = nsr['properties']['direction']
+          hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Fog
+  module Network
+    class AzureRM
+      # Probe model for Network Service
+      class Probe < Fog::Model
+        identity :name
+        attribute :id
+        attribute :protocol
+        attribute :port
+        attribute :request_path
+        attribute :interval_in_seconds
+        attribute :number_of_probes
+
+        def self.parse(probe)
+          probe_prop = probe['properties']
+          hash = {}
+          hash['id'] = probe['id']
+          hash['name'] = probe['name']
+          hash['protocol'] = probe_prop['protocol']
+          hash['port'] = probe_prop['port']
+          hash['request_path'] = probe_prop['requestPath']
+          hash['interval_in_seconds'] = probe_prop['intervalInSeconds']
+          hash['number_of_probes'] = probe_prop['numberOfProbes']
+          hash
+        end
+      end
+    end
+  end
+end

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

@@ -4,17 +4,45 @@ module Fog
       # PublicIP model class for Network Service
       class PublicIp < Fog::Model
         identity :name
-        attribute :type
+        attribute :id
         attribute :location
         attribute :resource_group
+        attribute :ip_address
+        attribute :public_ip_allocation_method
+        attribute :idle_timeout_in_minutes
+        attribute :ip_configuration_id
+        attribute :domain_name_label
+        attribute :fqdn
+        attribute :reverse_fqdn
+
+        def self.parse(pip)
+          pip_properties = pip['properties']
+          hash = {}
+          hash['id'] = pip['id']
+          hash['name'] = pip['name']
+          hash['location'] = pip['location']
+          hash['resource_group'] = pip['id'].split('/')[4]
+          hash['public_ip_allocation_method'] = pip_properties['publicIPAllocationMethod']
+          hash['ip_address'] = pip_properties['ipAddress']
+          hash['idle_timeout_in_minutes'] = pip_properties['idleTimeoutInMinutes']
+          hash['ip_configuration_id'] = pip_properties['ipConfiguration']['id'] unless pip_properties['ipConfiguration'].nil?
+
+          unless pip_properties['dnsSettings'].nil?
+            hash['domain_name_label'] = pip_properties['dnsSettings']['domainNameLabel']
+            hash['fqdn'] = pip_properties['dnsSettings']['fqdn']
+            hash['reverse_fqdn'] = pip_properties['dnsSettings']['reverseFqdn']
+          end
+
+          hash
+        end
 
         def save
           requires :name
-          requires :type
+          requires :public_ip_allocation_method
           requires :location
           requires :resource_group
-
-          service.create_public_ip(resource_group, name, location, type)
+          pip = service.create_public_ip(resource_group, name, location, public_ip_allocation_method)
+          merge_attributes(Fog::Network::AzureRM::PublicIp.parse(pip))
         end
 
         def destroy

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

@@ -12,14 +12,8 @@ module Fog
         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
+          service.list_public_ips(resource_group).each do |pip|
+            public_ips << Fog::Network::AzureRM::PublicIp.parse(pip)
           end
           load(public_ips)
         end

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

@@ -7,26 +7,34 @@ module Fog
         attribute :id
         attribute :resource_group
         attribute :virtual_network_name
-        attribute :properties
-        attribute :addressPrefix
-        attribute :networkSecurityGroupId
-        attribute :routeTableId
-        attribute :ipConfigurations
+        attribute :address_prefix
+        attribute :network_security_group_id
+        attribute :route_table_id
+        attribute :ip_configurations_ids
+
+        def self.parse(subnet)
+          hash = {}
+          hash['id'] = subnet['id']
+          hash['name'] = subnet['name']
+          hash['resource_group'] = subnet['id'].split('/')[4]
+          hash['virtual_network_name'] = subnet['id'].split('/')[8]
+          hash['address_prefix'] = subnet['properties']['addressPrefix']
+          hash['network_security_group_id'] = subnet['properties']['networkSecurityGroup']['id'] unless subnet['properties']['networkSecurityGroup'].nil?
+          hash['route_table_id'] = subnet['properties']['routeTable']['id'] unless subnet['properties']['routeTable'].nil?
+          hash['ip_configurations_ids'] = subnet['properties']['ipConfigurations'].map{ |item| item['id'] } unless subnet['properties']['ipConfigurations'].nil?
+          hash
+        end
 
         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
+          subnet = service.create_subnet(resource_group, name, virtual_network_name, address_prefix)
+          merge_attributes(Fog::Network::AzureRM::Subnet.parse(subnet))
         end
 
         def destroy
-          service.delete_subnet(resource_group, virtual_network_name, name)
+          service.delete_subnet(resource_group, name, virtual_network_name)
         end
       end
     end

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

@@ -15,13 +15,7 @@ module Fog
           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
+            subnets << Fog::Network::AzureRM::Subnet.parse(subnet)
           end
           load(subnets)
         end

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

@@ -0,0 +1,63 @@
+module Fog
+  module Network
+    class AzureRM
+      # Traffic Manager End Point model for Network Service
+      class TrafficManagerEndPoint < Fog::Model
+        identity :name
+        attribute :traffic_manager_profile_name
+        attribute :id
+        attribute :resource_group
+        attribute :type
+        attribute :target_resource_id
+        attribute :target
+        attribute :endpoint_status
+        attribute :endpoint_monitor_status
+        attribute :weight
+        attribute :priority
+        attribute :endpoint_location
+        attribute :min_child_endpoints
+
+        def self.parse(endpoint)
+          hash = {}
+          hash['id'] = endpoint['id']
+          hash['name'] = endpoint['name']
+          hash['resource_group'] = endpoint['id'].split('/')[4]
+          type = endpoint['type'].split('/')[2]
+          type.slice!('Endpoints')
+          hash['type'] = type
+          hash['target_resource_id'] = endpoint['properties']['targetResourceId']
+          hash['target'] = endpoint['properties']['target']
+          hash['endpoint_status'] = endpoint['properties']['endpointStatus']
+          hash['endpoint_monitor_status'] = endpoint['properties']['endpointMonitorStatus']
+          hash['weight'] = endpoint['properties']['weight']
+          hash['priority'] = endpoint['properties']['priority']
+          hash['endpoint_location'] = endpoint['properties']['endpointLocation']
+          hash['min_child_endpoints'] = endpoint['properties']['minChildEndpoints']
+          hash
+        end
+
+        def save
+          requires :name, :traffic_manager_profile_name, :resource_group, :type
+          requires :target_resource_id if type.eql?('azure')
+          requires :target, :endpoint_location if type.eql?('external')
+          requires :target_resource_id, :endpoint_location, :min_child_endpoints if type.eql?('nested')
+
+          if %w(azure external nested).select { |type| type if type.eql?(type) }.any?
+            traffic_manager_endpoint = service.create_traffic_manager_endpoint(resource_group, name,
+                                                                               traffic_manager_profile_name, type,
+                                                                               target_resource_id, target, weight,
+                                                                               priority, endpoint_location,
+                                                                               min_child_endpoints)
+            merge_attributes(Fog::Network::AzureRM::TrafficManagerEndPoint.parse(traffic_manager_endpoint))
+          else
+            raise(ArgumentError, ':type should be "azure", "external" or "nested"')
+          end
+        end
+
+        def destroy
+          service.delete_traffic_manager_endpoint(resource_group, name, traffic_manager_profile_name, type)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Fog
+  module Network
+    class AzureRM
+      # Traffic Manager End Point Collection for Network Service
+      class TrafficManagerEndPoints < Fog::Collection
+        attribute :resource_group
+        attribute :traffic_manager_profile_name
+        model Fog::Network::AzureRM::TrafficManagerEndPoint
+
+        def all
+          requires :resource_group
+          requires :traffic_manager_profile_name
+
+          traffic_manager_endpoints = []
+          profile = service.get_traffic_manager_profile(resource_group, traffic_manager_profile_name)
+          end_points = profile['properties']['endpoints']
+          end_points.each do |endpoint|
+            traffic_manager_endpoints << Fog::Network::AzureRM::TrafficManagerEndPoint.parse(endpoint)
+          end
+          load(traffic_manager_endpoints)
+        end
+
+        def get(identity)
+          all.find { |endpoint| endpoint.name == identity }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module Fog
+  module Network
+    class AzureRM
+      # Traffic Manager Profile model for Network Service
+      class TrafficManagerProfile < Fog::Model
+        identity :name
+        attribute :id
+        attribute :resource_group
+        attribute :location
+        attribute :profile_status
+        attribute :traffic_routing_method
+        attribute :relative_name
+        attribute :fqdn
+        attribute :ttl
+        attribute :profile_monitor_status
+        attribute :protocol
+        attribute :port
+        attribute :path
+        attribute :endpoints
+
+        def self.parse(profile)
+          hash = {}
+          hash['id'] = profile['id']
+          hash['name'] = profile['name']
+          hash['resource_group'] = profile['id'].split('/')[4]
+          hash['location'] = profile['location']
+          hash['profile_status'] = profile['properties']['profileStatus']
+          hash['traffic_routing_method'] = profile['properties']['trafficRoutingMethod']
+          hash['relative_name'] = profile['properties']['dnsConfig']['relativeName']
+          hash['fqdn'] = profile['properties']['dnsConfig']['fqdn']
+          hash['ttl'] = profile['properties']['dnsConfig']['ttl']
+          hash['profile_monitor_status'] = profile['properties']['monitorConfig']['profileMonitorStatus']
+          hash['protocol'] = profile['properties']['monitorConfig']['protocol']
+          hash['port'] = profile['properties']['monitorConfig']['port']
+          hash['path'] = profile['properties']['monitorConfig']['path']
+          hash['endpoints'] = []
+          profile['properties']['endpoints'].each do |endpoint|
+            end_point = Fog::Network::AzureRM::TrafficManagerEndPoint.new
+            hash['endpoints'] << end_point.merge_attributes(Fog::Network::AzureRM::TrafficManagerEndPoint.parse(endpoint))
+          end
+          hash
+        end
+
+        def save
+          requires :name, :resource_group, :traffic_routing_method, :relative_name, :ttl,
+                   :protocol, :port, :path
+          traffic_manager_profile = service.create_traffic_manager_profile(resource_group, name,
+                                                                           traffic_routing_method, relative_name, ttl,
+                                                                           protocol, port, path)
+          merge_attributes(Fog::Network::AzureRM::TrafficManagerProfile.parse(traffic_manager_profile))
+        end
+
+        def destroy
+          service.delete_traffic_manager_profile(resource_group, name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Fog
+  module Network
+    class AzureRM
+      # Traffic Manager Profile Collection for Network Service
+      class TrafficManagerProfiles < Fog::Collection
+        attribute :resource_group
+        model Fog::Network::AzureRM::TrafficManagerProfile
+
+        def all
+          requires :resource_group
+          traffic_manager_profiles = []
+          service.list_traffic_manager_profiles(resource_group).each do |profile|
+            traffic_manager_profiles << Fog::Network::AzureRM::TrafficManagerProfile.parse(profile)
+          end
+          load(traffic_manager_profiles)
+        end
+
+        def get(identity)
+          all.find { |profile| profile.name == identity }
+        end
+      end
+    end
+  end
+end

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

@@ -5,20 +5,33 @@ module Fog
         identity :name
         attribute :id
         attribute :location
+        attribute :resource_group
         attribute :dns_list
         attribute :subnet_address_list
         attribute :network_address_list
-        attribute :resource_group
-        attribute :properties
+
+        def self.parse(vnet)
+          hash = {}
+          hash['id'] = vnet['id']
+          hash['name'] = vnet['name']
+          hash['resource_group'] = vnet['id'].split('/')[4]
+          hash['location'] = vnet['location']
+          hash['dns_list'] = vnet['properties']['dhcpOptions']['dnsServers'].join(',') unless vnet['properties']['dhcpOptions'].nil?
+          hash['network_address_list'] = vnet['properties']['addressSpace']['addressPrefixes'].join(',') unless vnet['properties']['addressSpace']['addressPrefixes'].nil?
+          subnet_address_list = []
+          vnet['properties']['subnets'].each do |subnet|
+            subnet_address_list << subnet['properties']['addressPrefix']
+          end
+          hash['subnet_address_list'] = subnet_address_list.join(',')
+          hash
+        end
 
         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
+          vnet = service.create_virtual_network(resource_group, name, location, dns_list, subnet_address_list, network_address_list)
+          merge_attributes(Fog::Network::AzureRM::VirtualNetwork.parse(vnet))
         end
 
         def destroy