fog-azure-rm 0.0.5 → 0.0.6

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

@@ -39,62 +39,62 @@ module Fog
 
           hash['gateway_ip_configurations'] = []
           gateway.gateway_ipconfigurations.each do |ip_configuration|
-            gateway_ip_configuration = Fog::ApplicationGateway::AzureRM::IPConfiguration.new
-            hash['gateway_ip_configurations'] << gateway_ip_configuration.merge_attributes(Fog::ApplicationGateway::AzureRM::IPConfiguration.parse(ip_configuration))
+            gateway_ip_configuration = IPConfiguration.new
+            hash['gateway_ip_configurations'] << gateway_ip_configuration.merge_attributes(IPConfiguration.parse(ip_configuration))
           end unless gateway.gateway_ipconfigurations.nil?
 
           hash['ssl_certificates'] = []
           gateway.ssl_certificates.each do |certificate|
-            ssl_certificate = Fog::ApplicationGateway::AzureRM::SslCertificate.new
-            hash['ssl_certificates'] << ssl_certificate.merge_attributes(Fog::ApplicationGateway::AzureRM::SslCertificate.parse(certificate))
+            ssl_certificate = SslCertificate.new
+            hash['ssl_certificates'] << ssl_certificate.merge_attributes(SslCertificate.parse(certificate))
           end unless gateway.ssl_certificates.nil?
 
           hash['frontend_ip_configurations'] = []
           gateway.frontend_ipconfigurations.each do |frontend_ip_config|
-            frontend_ip_configuration = Fog::ApplicationGateway::AzureRM::FrontendIPConfiguration.new
-            hash['frontend_ip_configurations'] << frontend_ip_configuration.merge_attributes(Fog::ApplicationGateway::AzureRM::FrontendIPConfiguration.parse(frontend_ip_config))
+            frontend_ip_configuration = FrontendIPConfiguration.new
+            hash['frontend_ip_configurations'] << frontend_ip_configuration.merge_attributes(FrontendIPConfiguration.parse(frontend_ip_config))
           end unless gateway.frontend_ipconfigurations.nil?
 
           hash['frontend_ports'] = []
           gateway.frontend_ports.each do |port|
-            frontend_port = Fog::ApplicationGateway::AzureRM::FrontendPort.new
-            hash['frontend_ports'] << frontend_port.merge_attributes(Fog::ApplicationGateway::AzureRM::FrontendPort.parse(port))
+            frontend_port = FrontendPort.new
+            hash['frontend_ports'] << frontend_port.merge_attributes(FrontendPort.parse(port))
           end unless gateway.frontend_ports.nil?
 
           hash['probes'] = []
           gateway.probes.each do |probe|
-            gateway_probe = Fog::ApplicationGateway::AzureRM::Probe.new
-            hash['probes'] << gateway_probe.merge_attributes(Fog::ApplicationGateway::AzureRM::Probe.parse(probe))
+            gateway_probe = Probe.new
+            hash['probes'] << gateway_probe.merge_attributes(Probe.parse(probe))
           end unless gateway.probes.nil?
 
           hash['backend_address_pools'] = []
           gateway.backend_address_pools.each do |address|
-            backend_address_pool = Fog::ApplicationGateway::AzureRM::BackendAddressPool.new
-            hash['backend_address_pools'] << backend_address_pool.merge_attributes(Fog::ApplicationGateway::AzureRM::BackendAddressPool.parse(address))
+            backend_address_pool = BackendAddressPool.new
+            hash['backend_address_pools'] << backend_address_pool.merge_attributes(BackendAddressPool.parse(address))
           end unless gateway.backend_address_pools.nil?
 
           hash['backend_http_settings_list'] = []
           gateway.backend_http_settings_collection.each do |http_setting|
-            backend_http_setting = Fog::ApplicationGateway::AzureRM::BackendHttpSetting.new
-            hash['backend_http_settings_list'] << backend_http_setting.merge_attributes(Fog::ApplicationGateway::AzureRM::BackendHttpSetting.parse(http_setting))
+            backend_http_setting = BackendHttpSetting.new
+            hash['backend_http_settings_list'] << backend_http_setting.merge_attributes(BackendHttpSetting.parse(http_setting))
           end unless gateway.backend_http_settings_collection.nil?
 
           hash['http_listeners'] = []
           gateway.http_listeners.each do |listener|
-            http_listener = Fog::ApplicationGateway::AzureRM::HttpListener.new
-            hash['http_listeners'] << http_listener.merge_attributes(Fog::ApplicationGateway::AzureRM::HttpListener.parse(listener))
+            http_listener = HttpListener.new
+            hash['http_listeners'] << http_listener.merge_attributes(HttpListener.parse(listener))
           end unless gateway.http_listeners.nil?
 
           hash['url_path_maps'] = []
           gateway.url_path_maps.each do |map|
-            url_path_map = Fog::ApplicationGateway::AzureRM::UrlPathMap.new
-            hash['url_path_maps'] << url_path_map.merge_attributes(Fog::ApplicationGateway::AzureRM::UrlPathMap.parse(map))
+            url_path_map = UrlPathMap.new
+            hash['url_path_maps'] << url_path_map.merge_attributes(UrlPathMap.parse(map))
           end unless gateway.url_path_maps.nil?
 
           hash['request_routing_rules'] = []
           gateway.request_routing_rules.each do |rule|
-            request_routing_rule = Fog::ApplicationGateway::AzureRM::RequestRoutingRule.new
-            hash['request_routing_rules'] << request_routing_rule.merge_attributes(Fog::ApplicationGateway::AzureRM::RequestRoutingRule.parse(rule))
+            request_routing_rule = RequestRoutingRule.new
+            hash['request_routing_rules'] << request_routing_rule.merge_attributes(RequestRoutingRule.parse(rule))
           end unless gateway.request_routing_rules.nil?
           hash
         end
@@ -112,11 +112,32 @@ module Fog
           validate_http_listeners(http_listeners) unless http_listeners.nil?
           validate_url_path_maps(url_path_maps) unless url_path_maps.nil?
           validate_request_routing_rules(request_routing_rules) unless request_routing_rules.nil?
-
-          gateway = service.create_application_gateway(name, location, resource_group, sku_name, sku_tier, sku_capacity, gateway_ip_configurations, ssl_certificates, frontend_ip_configurations, frontend_ports, probes, backend_address_pools, backend_http_settings_list, http_listeners, url_path_maps, request_routing_rules)
+          gateway_params = get_gateway_params
+          gateway = service.create_or_update_application_gateway(gateway_params)
           merge_attributes(Fog::ApplicationGateway::AzureRM::Gateway.parse(gateway))
         end
 
+        def get_gateway_params
+          {
+            name: name,
+            location: location,
+            resource_group: resource_group,
+            sku_name: sku_name,
+            sku_tier: sku_tier,
+            sku_capacity: sku_capacity,
+            gateway_ip_configurations: gateway_ip_configurations,
+            ssl_certificates: ssl_certificates,
+            frontend_ip_configurations: frontend_ip_configurations,
+            frontend_ports: frontend_ports,
+            probes: probes,
+            backend_address_pools: backend_address_pools,
+            backend_http_settings_list: backend_http_settings_list,
+            http_listeners: http_listeners,
+            url_path_maps: url_path_maps,
+            request_routing_rules: request_routing_rules
+          }
+        end
+
         def validate_gateway_ip_configurations(gateway_ip_configurations)
           if gateway_ip_configurations.is_a?(Array)
             if gateway_ip_configurations.any?
@@ -443,6 +464,143 @@ module Fog
           end
         end
 
+        def serialize_sub_resources(gateway_params)
+          ip_configurations = []
+          gateway_params[:gateway_ip_configurations].each do |ip_configuration|
+            hash = {}
+            ip_configuration.attributes.each { |key, value| hash[key] = value }
+            ip_configurations << hash
+          end
+          gateway_params[:gateway_ip_configurations] = ip_configurations
+          ssl_certificates = []
+          gateway_params[:ssl_certificates].each do |ssl_certificate|
+            hash = {}
+            ssl_certificate.attributes.each { |key, value| hash[key] = value }
+            ssl_certificates << hash
+          end
+          gateway_params[:ssl_certificates] = ssl_certificates
+          frontend_ip_configurations = []
+          gateway_params[:frontend_ip_configurations].each do |frontend_ip_configuration|
+            hash = {}
+            frontend_ip_configuration.attributes.each { |key, value| hash[key] = value }
+            frontend_ip_configurations << hash
+          end
+          gateway_params[:frontend_ip_configurations] = frontend_ip_configurations
+          frontend_ports = []
+          gateway_params[:frontend_ports].each do |frontend_port|
+            hash = {}
+            frontend_port.attributes.each { |key, value| hash[key] = value }
+            frontend_ports << hash
+          end
+          gateway_params[:frontend_ports] = frontend_ports
+          probes = []
+          gateway_params[:probes].each do |probe|
+            hash = {}
+            probe.attributes.each { |key, value| hash[key] = value }
+            probes << hash
+          end
+          gateway_params[:probes] = probes
+          backend_address_pools = []
+          gateway_params[:backend_address_pools].each do |backend_address_pool|
+            hash = {}
+            backend_address_pool.attributes.each { |key, value| hash[key] = value }
+            backend_address_pools << hash
+          end
+          gateway_params[:backend_address_pools] = backend_address_pools
+          backend_address_ip_addresses = []
+          gateway_params[:backend_address_pools].each do |backend_address_pool|
+            backend_address_pool[:ip_addresses].each do |ip_address|
+              hash = {}
+              ip_address.instance_variables.each_with_object({}) { |instance_variable| hash[:ipAddress] = ip_address.instance_variable_get(instance_variable) }
+              backend_address_ip_addresses << hash
+            end
+            backend_address_pool[:ip_addresses] = backend_address_ip_addresses
+          end
+          backend_http_settings_list = []
+          gateway_params[:backend_http_settings_list].each do |backend_http_setting|
+            hash = {}
+            backend_http_setting.attributes.each { |key, value| hash[key] = value }
+            backend_http_settings_list << hash
+          end
+          gateway_params[:backend_http_settings_list] = backend_http_settings_list
+          http_listeners = []
+          gateway_params[:http_listeners].each do |http_listener|
+            hash = {}
+            http_listener.attributes.each { |key, value| hash[key] = value }
+            http_listeners << hash
+          end
+          gateway_params[:http_listeners] = http_listeners
+          url_path_maps = []
+          gateway_params[:url_path_maps].each do |url_path_map|
+            hash = {}
+            url_path_map.attributes.each { |key, value| hash[key] = value }
+            url_path_maps << hash
+          end
+          gateway_params[:url_path_maps] = url_path_maps
+          request_routing_rules = []
+          gateway_params[:request_routing_rules].each do |request_routing_rule|
+            hash = {}
+            request_routing_rule.attributes.each { |key, value| hash[key] = value }
+            request_routing_rules << hash
+          end
+          gateway_params[:request_routing_rules] = request_routing_rules
+          gateway_params
+        end
+
+        def update_sku(sku_name, sku_capacity = nil)
+          gateway_hash = serialize_sub_resources(get_gateway_params)
+          gateway = service.update_sku_attributes(gateway_hash, sku_name, sku_capacity)
+          merge_attributes(Fog::ApplicationGateway::AzureRM::Gateway.parse(gateway))
+        end
+
+        def update_gateway_ip_configuration(subnet_id)
+          gateway_hash = serialize_sub_resources(get_gateway_params)
+          gateway = service.update_subnet_id_in_gateway_ip_configuration(gateway_hash, subnet_id)
+          merge_attributes(Fog::ApplicationGateway::AzureRM::Gateway.parse(gateway))
+        end
+
+        def add_ssl_certificate(ssl_certificate_obj)
+          gateway_hash = serialize_sub_resources(get_gateway_params)
+          gateway_hash[:ssl_certificates] << ssl_certificate_obj
+          gateway = service.create_or_update_application_gateway(gateway_hash)
+          merge_attributes(Fog::ApplicationGateway::AzureRM::Gateway.parse(gateway))
+        end
+
+        def remove_ssl_certificate(ssl_certificate_obj)
+          gateway_hash = serialize_sub_resources(get_gateway_params)
+          gateway_hash[:ssl_certificates].delete(ssl_certificate_obj)
+          gateway = service.create_or_update_application_gateway(gateway_hash)
+          merge_attributes(Fog::ApplicationGateway::AzureRM::Gateway.parse(gateway))
+        end
+
+        def add_frontend_port(frontend_port_obj)
+          gateway_hash = serialize_sub_resources(get_gateway_params)
+          gateway_hash[:frontend_ports] << frontend_port_obj
+          gateway = service.create_or_update_application_gateway(gateway_hash)
+          merge_attributes(Fog::ApplicationGateway::AzureRM::Gateway.parse(gateway))
+        end
+
+        def remove_frontend_port(frontend_port_obj)
+          gateway_hash = serialize_sub_resources(get_gateway_params)
+          gateway_hash[:frontend_ports].delete(frontend_port_obj)
+          gateway = service.create_or_update_application_gateway(gateway_hash)
+          merge_attributes(Fog::ApplicationGateway::AzureRM::Gateway.parse(gateway))
+        end
+
+        def add_probe(probe_obj)
+          gateway_hash = serialize_sub_resources(get_gateway_params)
+          gateway_hash[:probes] << probe_obj
+          gateway = service.create_or_update_application_gateway(gateway_hash)
+          merge_attributes(Fog::ApplicationGateway::AzureRM::Gateway.parse(gateway))
+        end
+
+        def remove_probe(probe_obj)
+          gateway_hash = serialize_sub_resources(get_gateway_params)
+          gateway_hash[:probes].delete(probe_obj)
+          gateway = service.create_or_update_application_gateway(gateway_hash)
+          merge_attributes(Fog::ApplicationGateway::AzureRM::Gateway.parse(gateway))
+        end
+
         def destroy
           service.delete_application_gateway(resource_group, name)
         end

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

@@ -18,8 +18,10 @@ module Fog
           load(application_gateways)
         end
 
-        def get(identity)
-          all.find { |f| f.name == identity }
+        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))
         end
       end
     end

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

@@ -8,8 +8,13 @@ module Fog
 
         def self.parse(gateway_ip_configuration)
           hash = {}
-          hash['name'] = gateway_ip_configuration.name
-          hash['subnet_id'] = gateway_ip_configuration.subnet.id unless gateway_ip_configuration.subnet.nil?
+          if gateway_ip_configuration.is_a? Hash
+            hash['name'] = gateway_ip_configuration['name']
+            hash['subnet_id'] = gateway_ip_configuration['subnet']['id'] unless gateway_ip_configuration['subnet'].nil?
+          else
+            hash['name'] = gateway_ip_configuration.name
+            hash['subnet_id'] = gateway_ip_configuration.subnet.id unless gateway_ip_configuration.subnet.nil?
+          end
           hash
         end
       end

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

@@ -28,6 +28,7 @@ module Fog
         attribute :enable_automatic_updates
         attribute :network_interface_card_id
         attribute :availability_set_id
+        attribute :custom_data
 
         def self.parse(vm)
           hash = {}
@@ -43,6 +44,7 @@ module Fog
           hash['sku'] = vm.storage_profile.image_reference.sku
           hash['version'] = vm.storage_profile.image_reference.version
           hash['username'] = vm.os_profile.admin_username
+          hash['custom_data'] = vm.os_profile.custom_data
           hash['data_disks'] = []
 
           vm.storage_profile.data_disks.each do |disk|
@@ -64,7 +66,7 @@ module Fog
         def save
           requires :name, :location, :resource_group, :vm_size, :storage_account_name,
                    :username, :password, :network_interface_card_id, :publisher, :offer, :sku, :version
-          requires :disable_password_authentication if platform.casecmp('linux') == 0
+          requires :disable_password_authentication if platform.casecmp('linux').zero?
           ssh_key_path = "/home/#{username}/.ssh/authorized_keys" unless ssh_key_data.nil?
           virtual_machine_params = get_virtual_machine_params(ssh_key_path)
           vm = service.create_virtual_machine(virtual_machine_params)
@@ -139,7 +141,8 @@ module Fog
             version: version,
             platform: platform,
             provision_vm_agent: provision_vm_agent,
-            enable_automatic_updates: enable_automatic_updates
+            enable_automatic_updates: enable_automatic_updates,
+            custom_data: custom_data
           }
         end
       end

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

@@ -19,14 +19,10 @@ module Fog
           load(virtual_machines)
         end
 
-        def get(identity)
-          all.find { |s| s.name == identity }
-        end
-
-        def get_from_remote(resource_group, name)
-          result_obj = service.get_virtual_machine(resource_group, name)
-          model_obj = Fog::Compute::AzureRM::Server.new
-          model_obj.merge_attributes(Fog::Compute::AzureRM::Server.parse(result_obj))
+        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))
         end
       end
     end

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

@@ -0,0 +1,58 @@
+module Fog
+  module Network
+    class AzureRM
+      # Express Route Circuit Authorization model class for Network Service
+      class ExpressRouteCircuitAuthorization < Fog::Model
+        identity :name
+        attribute :id
+        attribute :resource_group
+        attribute :authorization_name
+        attribute :authorization_key
+        attribute :authorization_status
+        attribute :provisioning_state
+        attribute :etag
+        attribute :circuit_name
+
+        def self.parse(circuit_authorization)
+          circuit_auth_hash = {}
+          circuit_auth_hash['id'] = circuit_authorization.id
+          circuit_auth_hash['resource_group'] = get_resource_group_from_id(circuit_authorization.id)
+          circuit_auth_hash['circuit_name'] = get_circuit_name_from_id(circuit_authorization.id)
+          circuit_auth_hash['authorization_key'] = circuit_authorization.authorization_key
+          circuit_auth_hash['authorization_status'] = circuit_authorization.authorization_use_status
+          circuit_auth_hash['provisioning_state'] = circuit_authorization.provisioning_state
+          circuit_auth_hash['name'] = circuit_authorization.name
+          circuit_auth_hash['etag'] = circuit_authorization.etag
+
+          circuit_auth_hash
+        end
+
+        def save
+          requires :name, :resource_group, :circuit_name
+          circuit_authorization_parameters = express_route_circuit_authorization_params
+          circuit_authorization = service.create_or_update_express_route_circuit_authorization(circuit_authorization_parameters)
+          merge_attributes(ExpressRouteCircuitAuthorization.parse(circuit_authorization))
+        end
+
+        def destroy
+          service.delete_express_route_circuit_authorization(resource_group, circuit_name, name)
+        end
+
+        private
+
+        def express_route_circuit_authorization_params
+          {
+            name: name,
+            resource_group: resource_group,
+            circuit_name: circuit_name,
+            authorization_name: authorization_name,
+            authorization_key: authorization_key,
+            authorization_status: authorization_status,
+            provisioning_state: provisioning_state,
+            etag: etag
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'fog/core/collection'
+require 'fog/azurerm/models/network/express_route_circuit_authorization'
+
+module Fog
+  module Network
+    class AzureRM
+      # ExpressRouteCircuitAuthorization collection class for Network Service
+      class ExpressRouteCircuitAuthorizations < Fog::Collection
+        model ExpressRouteCircuitAuthorization
+        attribute :resource_group
+        attribute :circuit_name
+
+        def all
+          requires :resource_group
+          requires :circuit_name
+          circuit_authorizations = []
+          service.list_express_route_circuit_authorizations(resource_group, circuit_name).each do |circuit_authorization|
+            circuit_authorizations << ExpressRouteCircuitAuthorization.parse(circuit_authorization)
+          end
+          load(circuit_authorizations)
+        end
+
+        def get(resource_group_name, circuit_name, authorization_name)
+          circuit_authorization = service.get_express_route_circuit_authorization(resource_group_name, circuit_name, authorization_name)
+          express_route_circuit_authorization = ExpressRouteCircuitAuthorization.new(service: service)
+          express_route_circuit_authorization.merge_attributes(ExpressRouteCircuitAuthorization.parse(circuit_authorization))
+        end
+      end
+    end
+  end
+end

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

@@ -18,8 +18,10 @@ module Fog
           load(load_balancers)
         end
 
-        def get(identity)
-          all.find { |f| f.name == identity }
+        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))
         end
       end
     end

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

@@ -0,0 +1,68 @@
+module Fog
+  module Network
+    class AzureRM
+      # LocalNetworkGateway model class for Network Service
+      class LocalNetworkGateway < Fog::Model
+        identity :name
+        attribute :id
+        attribute :location
+        attribute :type
+        attribute :resource_group
+        attribute :tags
+        attribute :local_network_address_space_prefixes
+        attribute :gateway_ip_address
+        attribute :asn
+        attribute :bgp_peering_address
+        attribute :peer_weight
+        attribute :provisioning_state
+
+        def self.parse(local_network_gateway)
+          local_network_gateway_hash = {}
+          local_network_gateway_hash['id'] = local_network_gateway.id
+          local_network_gateway_hash['name'] = local_network_gateway.name
+          local_network_gateway_hash['location'] = local_network_gateway.location
+          local_network_gateway_hash['type'] = local_network_gateway.type
+          local_network_gateway_hash['resource_group'] = get_resource_group_from_id(local_network_gateway.id)
+          local_network_gateway_hash['tags'] = local_network_gateway.tags
+          local_network_address_space = local_network_gateway.local_network_address_space
+          local_network_gateway_hash['local_network_address_space_prefixes'] = local_network_address_space.address_prefixes unless local_network_address_space.nil?
+          local_network_gateway_hash['gateway_ip_address'] = local_network_gateway.gateway_ip_address
+          bgp_settings = local_network_gateway.bgp_settings
+          unless bgp_settings.nil?
+            local_network_gateway_hash['asn'] = bgp_settings.asn
+            local_network_gateway_hash['bgp_peering_address'] = bgp_settings.bgp_peering_address
+            local_network_gateway_hash['peer_weight'] = bgp_settings.peer_weight
+          end
+          local_network_gateway_hash['provisioning_state'] = local_network_gateway.provisioning_state
+          local_network_gateway_hash
+        end
+
+        def save
+          requires :name, :location, :resource_group, :local_network_address_space_prefixes, :gateway_ip_address, :asn, :bgp_peering_address, :peer_weight
+          local_network_gateway_params = local_network_gateway_parameters
+          local_network_gateway = service.create_or_update_local_network_gateway(local_network_gateway_params)
+          merge_attributes(LocalNetworkGateway.parse(local_network_gateway))
+        end
+
+        def destroy
+          service.delete_local_network_gateway(resource_group, name)
+        end
+
+        private
+
+        def local_network_gateway_parameters
+          {
+            name: name,
+            location: location,
+            resource_group: resource_group,
+            local_network_address_space_prefixes: local_network_address_space_prefixes,
+            gateway_ip_address: gateway_ip_address,
+            asn: asn,
+            bgp_peering_address: bgp_peering_address,
+            peer_weight: peer_weight
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'fog/core/collection'
+require 'fog/azurerm/models/network/local_network_gateway'
+
+module Fog
+  module Network
+    class AzureRM
+      # LocalNetworkGateways collection class for Network Service
+      class LocalNetworkGateways < Fog::Collection
+        model Fog::Network::AzureRM::LocalNetworkGateway
+        attribute :resource_group
+
+        def all
+          requires :resource_group
+          local_network_gateways = []
+          service.list_local_network_gateways(resource_group).each do |gateway|
+            local_network_gateways << LocalNetworkGateway.parse(gateway)
+          end
+          load(local_network_gateways)
+        end
+
+        def get(resource_group_name, name)
+          local_network_gateway = service.get_local_network_gateway(resource_group_name, name)
+          local_network_gateway_obj = LocalNetworkGateway.new(service: service)
+          local_network_gateway_obj.merge_attributes(LocalNetworkGateway.parse(local_network_gateway))
+        end
+      end
+    end
+  end
+end

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

@@ -40,13 +40,28 @@ module Fog
           requires :public_ip_allocation_method
           requires :location
           requires :resource_group
-          public_ip = service.create_public_ip(resource_group, name, location, public_ip_allocation_method)
+          public_ip = service.create_or_update_public_ip(resource_group, name, location, public_ip_allocation_method, idle_timeout_in_minutes, domain_name_label)
           merge_attributes(Fog::Network::AzureRM::PublicIp.parse(public_ip))
         end
 
         def destroy
           service.delete_public_ip(resource_group, name)
         end
+
+        def update(input_hash)
+          validate_input(input_hash)
+          merge_attributes(input_hash)
+          pip = service.create_or_update_public_ip(resource_group, name, location, public_ip_allocation_method, idle_timeout_in_minutes, domain_name_label)
+          merge_attributes(Fog::Network::AzureRM::PublicIp.parse(pip))
+        end
+
+        private
+
+        def validate_input(input_hash)
+          invalid_attr = [:resource_group, :name, :location, :id]
+          result = invalid_attr & input_hash.keys
+          raise 'Cannot modify the given attribute' unless result.empty?
+        end
       end
     end
   end