far-gem 0.5.1

data/lib/fog/azurerm/models/storage/sku_name.rb

@@ -0,0 +1,15 @@
+module Fog
+  module ARM
+    module Storage
+      module Models
+        module SkuName
+          StandardLRS = 'Standard_LRS'.freeze
+          StandardGRS = 'Standard_GRS'.freeze
+          StandardRAGRS = 'Standard_RAGRS'.freeze
+          StandardZRS = 'Standard_ZRS'.freeze
+          PremiumLRS = 'Premium_LRS'.freeze
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/storage/sku_tier.rb

@@ -0,0 +1,12 @@
+module Fog
+  module ARM
+    module Storage
+      module Models
+        module SkuTier
+          Standard = 'Standard'.freeze
+          Premium = 'Premium'.freeze
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/storage/storage_account.rb

@@ -0,0 +1,92 @@
+module Fog
+  module Storage
+    class AzureRM
+      # This class is giving implementation of create/save and
+      # delete/destroy for storage account.
+      class StorageAccount < Fog::Model
+        identity  :name
+        attribute :id
+        attribute :location
+        attribute :resource_group
+        attribute :sku_name
+        attribute :replication
+        attribute :encryption
+        attribute :tags
+
+        def self.parse(storage_account)
+          hash = {}
+          hash['id'] = storage_account.id
+          hash['name'] = storage_account.name
+          hash['location'] = storage_account.location
+          hash['resource_group'] = get_resource_group_from_id(storage_account.id)
+          hash['sku_name'] = storage_account.sku.name.split('_').first
+          hash['replication'] = storage_account.sku.name.split('_').last
+          hash['encryption'] = storage_account.encryption.services.blob.enabled unless storage_account.encryption.nil?
+          hash['tags'] = storage_account.tags
+          hash
+        end
+
+        def save
+          requires :name
+          requires :location
+          requires :resource_group
+          # Create a model for new storage account.
+          self.sku_name = STANDARD_STORAGE if sku_name.nil?
+          self.replication = ALLOWED_STANDARD_REPLICATION.first if replication.nil?
+          validate_sku_name!
+          storage_account = service.create_storage_account(storage_account_params)
+          merge_attributes(Fog::Storage::AzureRM::StorageAccount.parse(storage_account))
+        end
+
+        def storage_account_params
+          {
+            resource_group: resource_group,
+            name: name,
+            sku_name: sku_name,
+            location: location,
+            replication: replication,
+            encryption: encryption,
+            tags: tags
+          }
+        end
+
+        def update(storage_account_params)
+          validate_input(storage_account_params)
+          storage_account_params = merge_attributes(storage_account_params).all_attributes
+
+          storage_account = service.update_storage_account(storage_account_params)
+          merge_attributes(Fog::Storage::AzureRM::StorageAccount.parse(storage_account))
+        end
+
+        def validate_sku_name!
+          case sku_name
+          when STANDARD_STORAGE
+            raise 'Standard Replications can only be LRS, ZRS, GRS or RAGRS.' unless ALLOWED_STANDARD_REPLICATION.include?(replication)
+          when PREMIUM_STORAGE
+            raise 'Premium Replication can only be LRS.' if replication != 'LRS'
+          else
+            raise 'Account Type can only be Standard or Premium'
+          end
+        end
+
+        def get_access_keys(options = {})
+          service.get_storage_access_keys(resource_group, name, options)
+        end
+
+        def destroy
+          service.delete_storage_account(resource_group, name)
+        end
+
+        private
+
+        def validate_input(attr_hash)
+          invalid_attr = [:resource_group, :name, :location, :id]
+          result = invalid_attr & attr_hash.keys
+          raise 'Cannot modify the given attribute' unless result.empty?
+        end
+
+        private :storage_account_params, :validate_sku_name!
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/storage/storage_accounts.rb

@@ -0,0 +1,47 @@
+module Fog
+  module Storage
+    class AzureRM
+      # This class is giving implementation of all/list, get and
+      # check name availability for storage account.
+      class StorageAccounts < Fog::Collection
+        model Fog::Storage::AzureRM::StorageAccount
+        attribute :resource_group
+
+        def all
+          accounts = []
+          if !resource_group.nil?
+            requires :resource_group
+            hash_of_storage_accounts = service.list_storage_account_for_rg(resource_group)
+          else
+            hash_of_storage_accounts = service.list_storage_accounts
+          end
+          hash_of_storage_accounts.each do |account|
+            accounts << Fog::Storage::AzureRM::StorageAccount.parse(account)
+          end
+          load(accounts)
+        end
+
+        def get(resource_group_name, storage_account_name)
+          storage_account = service.get_storage_account(resource_group_name, storage_account_name)
+          storage_account_fog = Fog::Storage::AzureRM::StorageAccount.new(service: service)
+          storage_account_fog.merge_attributes(Fog::Storage::AzureRM::StorageAccount.parse(storage_account))
+        end
+
+        def check_name_availability(name, type = 'Microsoft.Storage/storageAccounts')
+          service.check_storage_account_name_availability(name, type)
+        end
+
+        def delete_storage_account_from_tag(resource_group_name, tag_key, tag_value)
+          storage_accounts = service.storage_accounts(resource_group: resource_group_name)
+          storage_accounts.each do |account|
+            account.destroy if account.tags[tag_key].eql? tag_value
+          end
+        end
+
+        def check_storage_account_exists(resource_group_name, storage_account_name)
+          service.check_storage_account_exists(resource_group_name, storage_account_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+module Fog
+  module TrafficManager
+    class AzureRM
+      # Traffic Manager End Point model for Traffic Manager 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)
+          traffic_manager_endpoint = get_hash_from_object(endpoint)
+          traffic_manager_endpoint['type'] = get_end_point_type(endpoint.type)
+          traffic_manager_endpoint['resource_group'] = get_resource_group_from_id(endpoint.id)
+          traffic_manager_endpoint['traffic_manager_profile_name'] = get_traffic_manager_profile_name_from_endpoint_id(endpoint.id)
+          traffic_manager_endpoint
+        end
+
+        def save
+          requires :name, :traffic_manager_profile_name, :resource_group, :type
+          requires :target_resource_id if type.eql?(AZURE_ENDPOINTS)
+          requires :target, :endpoint_location if type.eql?(EXTERNAL_ENDPOINTS)
+          requires :target_resource_id, :endpoint_location, :min_child_endpoints if type.eql?(NESTED_ENDPOINTS)
+
+          create_or_update
+        end
+
+        def destroy
+          service.delete_traffic_manager_endpoint(resource_group, name, traffic_manager_profile_name, type)
+        end
+
+        def update(endpoint_params)
+          validate_input(endpoint_params)
+          merge_attributes(endpoint_params)
+
+          create_or_update
+        end
+
+        private
+
+        def create_or_update
+          if %w(azureEndpoints externalEndpoints nestedEndpoints).select { |type| type if type.eql?(type) }.any?
+            traffic_manager_endpoint = service.create_or_update_traffic_manager_endpoint(traffic_manager_endpoint_hash)
+            merge_attributes(Fog::TrafficManager::AzureRM::TrafficManagerEndPoint.parse(traffic_manager_endpoint))
+          else
+            raise(ArgumentError, ":type should be '#{AZURE_ENDPOINTS}', '#{EXTERNAL_ENDPOINTS}' or '#{NESTED_ENDPOINTS}'")
+          end
+        end
+
+        def traffic_manager_endpoint_hash
+          {
+            resource_group: resource_group,
+            name: name,
+            traffic_manager_profile_name: traffic_manager_profile_name,
+            type: type,
+            target_resource_id: target_resource_id,
+            target: target,
+            weight: weight,
+            priority: priority,
+            endpoint_location: endpoint_location,
+            min_child_endpoints: min_child_endpoints
+          }
+        end
+
+        def validate_input(attr_hash)
+          invalid_attr = [:resource_group, :name, :traffic_manager_profile_name, :id]
+          result = invalid_attr & attr_hash.keys
+          raise 'Cannot modify the given attribute' unless result.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Fog
+  module TrafficManager
+    class AzureRM
+      # Traffic Manager End Point Collection for TrafficManager Service
+      class TrafficManagerEndPoints < Fog::Collection
+        attribute :resource_group
+        attribute :traffic_manager_profile_name
+        model Fog::TrafficManager::AzureRM::TrafficManagerEndPoint
+
+        def all
+          requires :resource_group, :traffic_manager_profile_name
+
+          end_points = service.get_traffic_manager_profile(resource_group, traffic_manager_profile_name).endpoints
+          traffic_manager_endpoints = end_points.map { |endpoint| Fog::TrafficManager::AzureRM::TrafficManagerEndPoint.parse(endpoint) }
+          load(traffic_manager_endpoints)
+        end
+
+        def get(resource_group, traffic_manager_profile_name, end_point_name, type)
+          endpoint = service.get_traffic_manager_end_point(resource_group, traffic_manager_profile_name, end_point_name, type)
+          endpoint_fog = Fog::TrafficManager::AzureRM::TrafficManagerEndPoint.new(service: service)
+          endpoint_fog.merge_attributes(Fog::TrafficManager::AzureRM::TrafficManagerEndPoint.parse(endpoint))
+        end
+
+        def check_traffic_manager_endpoint_exists(resource_group, traffic_manager_profile_name, end_point_name, type)
+          service.check_traffic_manager_endpoint_exists(resource_group, traffic_manager_profile_name, end_point_name, type)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+module Fog
+  module TrafficManager
+    class AzureRM
+      # Traffic Manager Profile model for TrafficManager 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
+        attribute :tags
+
+        def self.parse(profile)
+          traffic_manager_profile = get_hash_from_object(profile)
+
+          if profile.dns_config
+            traffic_manager_profile['relative_name'] = profile.dns_config.relative_name
+            traffic_manager_profile['fqdn'] = profile.dns_config.fqdn
+            traffic_manager_profile['ttl'] = profile.dns_config.ttl
+          end
+
+          if profile.monitor_config
+            traffic_manager_profile['profile_monitor_status'] = profile.monitor_config.profile_monitor_status
+            traffic_manager_profile['protocol'] = profile.monitor_config.protocol
+            traffic_manager_profile['port'] = profile.monitor_config.port
+            traffic_manager_profile['path'] = profile.monitor_config.path
+          end
+          traffic_manager_profile['resource_group'] = get_resource_group_from_id(profile.id)
+          traffic_manager_profile['endpoints'] = []
+          profile.endpoints.each do |endpoint|
+            end_point = Fog::TrafficManager::AzureRM::TrafficManagerEndPoint.new
+            traffic_manager_profile['endpoints'] << end_point.merge_attributes(Fog::TrafficManager::AzureRM::TrafficManagerEndPoint.parse(endpoint))
+          end
+          traffic_manager_profile
+        end
+
+        def save
+          requires :name, :resource_group, :traffic_routing_method, :relative_name, :ttl,
+                   :protocol, :port, :path
+          traffic_manager_profile = service.create_or_update_traffic_manager_profile(traffic_manager_profile_hash)
+          merge_attributes(Fog::TrafficManager::AzureRM::TrafficManagerProfile.parse(traffic_manager_profile))
+        end
+
+        def destroy
+          service.delete_traffic_manager_profile(resource_group, name)
+        end
+
+        def update(profile_params)
+          validate_input(profile_params)
+          profile_params[:endpoints] = endpoints.map { |endpoint| get_hash_from_object(endpoint)['attributes'] } unless endpoints.nil?
+          merge_attributes(profile_params)
+          profile = service.create_or_update_traffic_manager_profile(traffic_manager_profile_hash)
+          merge_attributes(Fog::TrafficManager::AzureRM::TrafficManagerProfile.parse(profile))
+        end
+
+        private
+
+        def validate_input(attr_hash)
+          invalid_attr = [:resource_group, :name, :relative_name, :id]
+          result = invalid_attr & attr_hash.keys
+          raise 'Cannot modify the given attribute' unless result.empty?
+        end
+
+        def traffic_manager_profile_hash
+          {
+            resource_group: resource_group,
+            name: name,
+            traffic_routing_method: traffic_routing_method,
+            relative_name: relative_name,
+            ttl: ttl,
+            protocol: protocol,
+            port: port,
+            path: path,
+            endpoints: endpoints,
+            tags: tags
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Fog
+  module TrafficManager
+    class AzureRM
+      # Traffic Manager Profile Collection for TrafficManager Service
+      class TrafficManagerProfiles < Fog::Collection
+        attribute :resource_group
+        model Fog::TrafficManager::AzureRM::TrafficManagerProfile
+
+        def all
+          requires :resource_group
+          traffic_manager_profiles = service.list_traffic_manager_profiles(resource_group).map { |profile| Fog::TrafficManager::AzureRM::TrafficManagerProfile.parse(profile) }
+          load(traffic_manager_profiles)
+        end
+
+        def get(resource_group, traffic_manager_profile_name)
+          profile = service.get_traffic_manager_profile(resource_group, traffic_manager_profile_name)
+          profile_fog = Fog::TrafficManager::AzureRM::TrafficManagerProfile.new(service: service)
+          profile_fog.merge_attributes(Fog::TrafficManager::AzureRM::TrafficManagerProfile.parse(profile))
+        end
+
+        def check_traffic_manager_profile_exists(resource_group, traffic_manager_profile_name)
+          service.check_traffic_manager_profile_exists(resource_group, traffic_manager_profile_name)
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/network.rb

@@ -0,0 +1,178 @@
+module Fog
+  module Network
+    # Fog Service Class for AzureRM
+    class AzureRM < Fog::Service
+      requires :tenant_id
+      requires :client_id
+      requires :client_secret
+      requires :subscription_id
+      recognizes :environment
+
+      request_path 'fog/azurerm/requests/network'
+      request :create_or_update_virtual_network
+      request :get_virtual_network
+      request :add_dns_servers_in_virtual_network
+      request :remove_dns_servers_from_virtual_network
+      request :add_address_prefixes_in_virtual_network
+      request :remove_subnets_from_virtual_network
+      request :remove_address_prefixes_from_virtual_network
+      request :add_subnets_in_virtual_network
+      request :delete_virtual_network
+      request :list_virtual_networks
+      request :list_virtual_networks_in_subscription
+      request :check_virtual_network_exists
+      request :create_or_update_public_ip
+      request :delete_public_ip
+      request :get_public_ip
+      request :list_public_ips
+      request :check_public_ip_exists
+      request :create_subnet
+      request :attach_network_security_group_to_subnet
+      request :detach_network_security_group_from_subnet
+      request :attach_route_table_to_subnet
+      request :detach_route_table_from_subnet
+      request :list_subnets
+      request :get_subnet
+      request :get_available_ipaddresses_count
+      request :delete_subnet
+      request :check_subnet_exists
+      request :create_or_update_network_interface
+      request :delete_network_interface
+      request :list_network_interfaces
+      request :get_network_interface
+      request :check_network_interface_exists
+      request :attach_resource_to_nic
+      request :detach_resource_from_nic
+      request :create_load_balancer
+      request :delete_load_balancer
+      request :list_load_balancers
+      request :get_load_balancer
+      request :check_load_balancer_exists
+      request :list_load_balancers_in_subscription
+      request :create_or_update_network_security_group
+      request :delete_network_security_group
+      request :list_network_security_groups
+      request :get_network_security_group
+      request :check_net_sec_group_exists
+      request :add_security_rules
+      request :remove_security_rule
+      request :delete_virtual_network_gateway
+      request :create_or_update_virtual_network_gateway
+      request :list_virtual_network_gateways
+      request :get_virtual_network_gateway
+      request :check_vnet_gateway_exists
+      request :create_or_update_express_route_circuit
+      request :delete_express_route_circuit
+      request :get_express_route_circuit
+      request :list_express_route_circuits
+      request :check_express_route_circuit_exists
+      request :create_or_update_express_route_circuit_peering
+      request :delete_express_route_circuit_peering
+      request :get_express_route_circuit_peering
+      request :list_express_route_circuit_peerings
+      request :create_or_update_express_route_circuit_authorization
+      request :delete_express_route_circuit_authorization
+      request :get_express_route_circuit_authorization
+      request :list_express_route_circuit_authorizations
+      request :check_express_route_cir_auth_exists
+      request :list_express_route_service_providers
+      request :create_or_update_local_network_gateway
+      request :delete_local_network_gateway
+      request :get_local_network_gateway
+      request :list_local_network_gateways
+      request :check_local_net_gateway_exists
+      request :create_or_update_virtual_network_gateway_connection
+      request :delete_virtual_network_gateway_connection
+      request :get_virtual_network_gateway_connection
+      request :list_virtual_network_gateway_connections
+      request :check_vnet_gateway_connection_exists
+      request :get_connection_shared_key
+      request :reset_connection_shared_key
+      request :set_connection_shared_key
+      request :create_or_update_network_security_rule
+      request :delete_network_security_rule
+      request :get_network_security_rule
+      request :list_network_security_rules
+      request :check_net_sec_rule_exists
+
+      model_path 'fog/azurerm/models/network'
+      model :virtual_network
+      collection :virtual_networks
+      model :public_ip
+      collection :public_ips
+      model :subnet
+      collection :subnets
+      model :network_interface
+      collection :network_interfaces
+      model :load_balancer
+      collection :load_balancers
+      model :frontend_ip_configuration
+      model :inbound_nat_pool
+      model :inbound_nat_rule
+      model :load_balancing_rule
+      model :probe
+      model :network_security_group
+      collection :network_security_groups
+      model :network_security_rule
+      collection :network_security_rules
+      model :path_rule
+      model :vpn_client_configuration
+      model :vpn_client_revoked_certificates
+      model :vpn_client_root_certificates
+      model :virtual_network_gateway
+      collection :virtual_network_gateways
+      model :express_route_circuit
+      collection :express_route_circuits
+      model :express_route_circuit_peering
+      collection :express_route_circuit_peerings
+      model :express_route_circuit_authorization
+      collection :express_route_circuit_authorizations
+      model :express_route_service_provider
+      collection :express_route_service_providers
+      model :local_network_gateway
+      collection :local_network_gateways
+      model :virtual_network_gateway_connection
+      collection :virtual_network_gateway_connections
+
+      # Mock class for Network Service
+      class Mock
+        def initialize(_options = {})
+          begin
+            require 'azure_mgmt_network'
+          rescue LoadError => e
+            retry if require('rubygems')
+            raise e.message
+          end
+        end
+      end
+
+      # Real class for Network Service
+      class Real
+        def initialize(options)
+          begin
+            require 'azure_mgmt_network'
+            require 'yaml'
+          rescue LoadError => e
+            retry if require('rubygems')
+            raise e.message
+          end
+
+          options[:environment] = 'AzureCloud' if options[:environment].nil?
+
+          credentials = Fog::Credentials::AzureRM.get_credentials(options[:tenant_id], options[:client_id], options[:client_secret], options[:environment])
+          telemetry = "fog-azure-rm/#{Fog::AzureRM::VERSION}"
+          @network_client = ::Azure::ARM::Network::NetworkManagementClient.new(credentials, resource_manager_endpoint_url(options[:environment]))
+          @network_client.subscription_id = options[:subscription_id]
+          @network_client.add_user_agent_information(telemetry)
+          @tenant_id = options[:tenant_id]
+          @client_id = options[:client_id]
+          @client_secret = options[:client_secret]
+          @subscription_id = options[:subscription_id]
+          @environment = options[:environment]
+          current_directory = File.dirname(__FILE__)
+          @logger_messages = YAML.load_file("#{current_directory}/utilities/logger_messages.yml")
+        end
+      end
+    end
+  end
+end