fog-azure-rm-temp 0.0.1

data/lib/fog/azurerm/resources.rb

@@ -0,0 +1,71 @@
+module Fog
+  module Resources
+    # This class registers models, requests and collections
+    class AzureRM < Fog::Service
+      requires :tenant_id
+      requires :client_id
+      requires :client_secret
+      requires :subscription_id
+      recognizes :environment
+
+      request_path 'fog/azurerm/requests/resources'
+      request :create_resource_group
+      request :list_resource_groups
+      request :delete_resource_group
+      request :get_resource_group
+      request :check_resource_group_exists
+      request :create_deployment
+      request :delete_deployment
+      request :list_deployments
+      request :get_deployment
+      request :check_deployment_exists
+      request :delete_resource_tag
+      request :list_tagged_resources
+      request :tag_resource
+      request :check_azure_resource_exists
+
+      model_path 'fog/azurerm/models/resources'
+      model :resource_group
+      collection :resource_groups
+      model :deployment
+      collection :deployments
+      model :dependency
+      model :provider
+      model :provider_resource_type
+      model :azure_resource
+      collection :azure_resources
+
+      # This class provides the mock implementation for unit tests.
+      class Mock
+        def initialize(_options = {})
+          begin
+            require 'azure_mgmt_resources'
+          rescue LoadError => e
+            retry if require('rubygems')
+            raise e.message
+          end
+        end
+      end
+
+      # This class provides the actual implementation for service calls.
+      class Real
+        def initialize(options)
+          begin
+            require 'azure_mgmt_resources'
+          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}"
+          @rmc = ::Azure::ARM::Resources::ResourceManagementClient.new(credentials, resource_manager_endpoint_url(options[:environment]))
+          @rmc.subscription_id = options[:subscription_id]
+          @rmc.add_user_agent_information(telemetry)
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/sql.rb

@@ -0,0 +1,66 @@
+module Fog
+  module Sql
+    # This class registers models, requests and collections
+    class AzureRM < Fog::Service
+      requires :tenant_id
+      requires :client_id
+      requires :client_secret
+      requires :subscription_id
+      recognizes :environment
+
+      request_path 'fog/azurerm/requests/sql'
+      request :create_or_update_sql_server
+      request :delete_sql_server
+      request :get_sql_server
+      request :list_sql_servers
+      request :check_sql_server_exists
+
+      request :create_or_update_database
+      request :delete_database
+      request :get_database
+      request :list_databases
+      request :check_database_exists
+
+      request :create_or_update_firewall_rule
+      request :delete_firewall_rule
+      request :get_firewall_rule
+      request :list_firewall_rules
+      request :check_firewall_rule_exists
+
+      model_path 'fog/azurerm/models/sql'
+      model :sql_server
+      collection :sql_servers
+
+      model :sql_database
+      collection :sql_databases
+
+      model :firewall_rule
+      collection :firewall_rules
+
+      # This class provides the actual implementation for service calls.
+      class Real
+        def initialize(options)
+          begin
+            require 'azure_mgmt_sql'
+          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])
+          @sql_mgmt_client = ::Azure::ARM::SQL::SqlManagementClient.new(credentials, resource_manager_endpoint_url(options[:environment]))
+          @sql_mgmt_client.subscription_id = options[:subscription_id]
+          telemetry = "fog-azure-rm/#{Fog::AzureRM::VERSION}"
+          @sql_mgmt_client.add_user_agent_information(telemetry)
+        end
+      end
+      # This class provides the mock implementation for unit tests.
+      class Mock
+        def initialize(_options = {})
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/storage.rb

@@ -0,0 +1,155 @@
+module Fog
+  module Storage
+    # This class registers models, requests and collections
+    class AzureRM < Fog::Service
+      # Recognizes when creating management client
+      recognizes :tenant_id
+      recognizes :client_id
+      recognizes :client_secret
+      recognizes :subscription_id
+      recognizes :environment
+
+      # Recognizes when creating data client
+      recognizes :azure_storage_account_name
+      recognizes :azure_storage_access_key
+      recognizes :debug
+
+      request_path 'fog/azurerm/requests/storage'
+      # Azure Storage Account requests
+      request :create_storage_account
+      request :update_storage_account
+      request :list_storage_accounts
+      request :delete_storage_account
+      request :get_storage_account
+      request :list_storage_account_for_rg
+      request :check_storage_account_name_availability
+      request :get_storage_access_keys
+      request :check_storage_account_exists
+      # Azure Storage Disk requests
+      request :delete_disk
+      request :create_disk
+      # Azure Storage Container requests
+      request :create_container
+      request :release_container_lease
+      request :acquire_container_lease
+      request :delete_container
+      request :list_containers
+      request :put_container_metadata
+      request :get_container_properties
+      request :get_container_acl
+      request :put_container_acl
+      request :get_container_url
+      request :check_container_exists
+      # Azure Storage Blob requests
+      request :list_blobs
+      request :put_blob_metadata
+      request :put_blob_properties
+      request :get_blob_properties
+      request :copy_blob
+      request :copy_blob_from_uri
+      request :compare_container_blobs
+      request :acquire_blob_lease
+      request :release_blob_lease
+      request :delete_blob
+      request :get_blob
+      request :get_blob_url
+      request :get_blob_http_url
+      request :get_blob_https_url
+      request :create_block_blob
+      request :put_blob_block
+      request :commit_blob_blocks
+      request :create_page_blob
+      request :put_blob_pages
+      request :wait_blob_copy_operation_to_finish
+      request :save_page_blob
+      request :multipart_save_block_blob
+
+      # Azure Recovery Vault requests
+      request :create_or_update_recovery_vault
+      request :get_recovery_vault
+      request :list_recovery_vaults
+      request :delete_recovery_vault
+      request :enable_backup_protection
+      request :set_recovery_vault_context
+      request :get_backup_protection_policy
+      request :start_backup
+      request :get_backup_item
+      request :get_backup_container
+      request :disable_backup_protection
+      request :get_all_backup_jobs
+      request :get_all_backup_jobs
+      request :get_backup_job_for_vm
+
+      model_path 'fog/azurerm/models/storage'
+      model :storage_account
+      collection :storage_accounts
+      model :data_disk
+      model :directory
+      collection :directories
+      model :file
+      collection :files
+      model :recovery_vault
+      collection :recovery_vaults
+
+      # This class provides the mock implementation for unit tests.
+      class Mock
+        def initialize(_options = {})
+          begin
+            require 'azure_mgmt_storage'
+          rescue LoadError => e
+            retry if require('rubygems')
+            raise e.message
+          end
+        end
+      end
+
+      # This class provides the actual implementation for service calls.
+      class Real
+        def initialize(options)
+          begin
+            require 'azure_mgmt_storage'
+            require 'azure/storage'
+            require 'securerandom'
+            require 'vhd'
+            @debug = ENV['DEBUG'] || options[:debug]
+            require 'azure/core/http/debug_filter' if @debug
+          rescue LoadError => e
+            retry if require('rubygems')
+            raise e.message
+          end
+
+          options[:environment] = 'AzureCloud' if options[:environment].nil?
+
+          @tenant_id = options[:tenant_id]
+          @client_id = options[:client_id]
+          @client_secret = options[:client_secret]
+          @subscription_id = options[:subscription_id]
+          @environment = options[:environment]
+
+          credentials = Fog::Credentials::AzureRM.get_credentials(@tenant_id, @client_id, @client_secret, @environment)
+          telemetry = "fog-azure-rm/#{Fog::AzureRM::VERSION}"
+          unless credentials.nil?
+            @storage_mgmt_client = ::Azure::ARM::Storage::StorageManagementClient.new(credentials, resource_manager_endpoint_url(@environment))
+            @storage_mgmt_client.subscription_id = @subscription_id
+            @storage_mgmt_client.add_user_agent_information(telemetry)
+          end
+
+          return unless @azure_storage_account_name != options[:azure_storage_account_name] ||
+                        @azure_storage_access_key != options[:azure_storage_access_key]
+
+          @azure_storage_account_name = options[:azure_storage_account_name]
+          @azure_storage_access_key = options[:azure_storage_access_key]
+
+          azure_client = Azure::Storage::Client.create(storage_account_name: @azure_storage_account_name,
+                                                       storage_access_key: @azure_storage_access_key)
+          azure_client.storage_blob_host = get_blob_endpoint(@azure_storage_account_name, true, @environment)
+          @blob_client = azure_client.blob_client
+          @blob_client.with_filter(Azure::Storage::Core::Filter::ExponentialRetryPolicyFilter.new)
+          @blob_client.with_filter(Azure::Core::Http::DebugFilter.new) if @debug
+          @signature_client = Azure::Storage::Core::Auth::SharedAccessSignature.new(@azure_storage_account_name,
+                                                                                    @azure_storage_access_key)
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/traffic_manager.rb

@@ -0,0 +1,62 @@
+module Fog
+  module TrafficManager
+    # This class registers models, requests and collections
+    class AzureRM < Fog::Service
+      requires :tenant_id
+      requires :client_id
+      requires :client_secret
+      requires :subscription_id
+      recognizes :environment
+
+      request_path 'fog/azurerm/requests/traffic_manager'
+      request :create_or_update_traffic_manager_profile
+      request :delete_traffic_manager_profile
+      request :get_traffic_manager_profile
+      request :list_traffic_manager_profiles
+      request :check_traffic_manager_profile_exists
+
+      request :create_or_update_traffic_manager_endpoint
+      request :delete_traffic_manager_endpoint
+      request :get_traffic_manager_endpoint
+      request :check_traffic_manager_endpoint_exists
+
+      model_path 'fog/azurerm/models/traffic_manager'
+      model :traffic_manager_profile
+      collection :traffic_manager_profiles
+
+      model :traffic_manager_end_point
+      collection :traffic_manager_end_points
+
+      # This class provides the actual implementation for service calls.
+      class Real
+        def initialize(options)
+          begin
+            require 'azure_mgmt_traffic_manager'
+          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}"
+          @traffic_mgmt_client = ::Azure::ARM::TrafficManager::TrafficManagerManagementClient.new(credentials, resource_manager_endpoint_url(options[:environment]))
+          @traffic_mgmt_client.subscription_id = options[:subscription_id]
+          @traffic_mgmt_client.add_user_agent_information(telemetry)
+        end
+      end
+      # This class provides the mock implementation for unit tests.
+      class Mock
+        def initialize(_options = {})
+          begin
+            require 'azure_mgmt_traffic_manager'
+          rescue LoadError => e
+            retry if require('rubygems')
+            raise e.message
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/utilities/general.rb

@@ -0,0 +1,168 @@
+# Pick Resource Group name from Azure Resource Id(String)
+def get_resource_group_from_id(id)
+  id.split('/')[4]
+end
+
+# Pick Virtual Network name from Subnet Resource Id(String)
+def get_virtual_network_from_id(subnet_id)
+  subnet_id.split('/')[8]
+end
+
+# Pick Virtual Machine name from Virtual Machine Extension Id(String)
+def get_virtual_machine_from_id(vme_id)
+  vme_id.split('/')[VM_NAME_POSITION]
+end
+
+# Extract Endpoint type from (String)
+def get_end_point_type(endpoint_type)
+  endpoint_type.split('/')[2]
+end
+
+def get_record_set_from_id(id)
+  id.split('/')[8]
+end
+
+def get_type_from_recordset_type(type)
+  type.split('/')[2]
+end
+
+def get_hash_from_object(object)
+  hash = {}
+  object.instance_variables.each { |attr| hash[attr.to_s.delete('@')] = object.instance_variable_get(attr) }
+  hash
+end
+
+# Extract Traffic Manager Profile Name from Endpoint id(String)
+def get_traffic_manager_profile_name_from_endpoint_id(endpoint_id)
+  endpoint_id.split('/')[8]
+end
+
+# Pick Express Route Circuit name from Id(String)
+def get_circuit_name_from_id(circuit_id)
+  circuit_id.split('/')[8]
+end
+
+def get_record_type(type)
+  type.split('/').last
+end
+
+def raise_azure_exception(exception, msg)
+  if exception.respond_to? 'body'
+    message = if exception.body['error'].nil?
+                exception.body['message']
+              else
+                exception.body['error']['message']
+              end
+    exception_message = "Exception in #{msg} #{message} Type: #{exception.class}\n#{exception.backtrace.join("\n")}"
+  else
+    "#{exception.inspect}\n#{exception.backtrace.join("\n")}"
+  end
+
+  Fog::Logger.debug exception.backtrace
+  raise exception_message
+end
+
+# Make sure if input_params(Hash) contains all keys present in required_params(Array)
+def validate_params(required_params, input_params)
+  missing_params = required_params.select { |param| param unless input_params.key?(param) }
+  raise(ArgumentError, "Missing Parameters: #{missing_params.join(', ')} required for this operation") if missing_params.any?
+end
+
+def get_resource_from_resource_id(resource_id, position)
+  data = resource_id.split('/') unless resource_id.nil?
+
+  raise 'Invalid Resource ID' if data.count < 9 && data.count != 5
+
+  data[position]
+end
+
+def random_string(length)
+  (0...length).map { ('a'..'z').to_a[rand(26)] }.join
+end
+
+def active_directory_service_settings(environment = ENVIRONMENT_AZURE_CLOUD)
+  case environment
+  when ENVIRONMENT_AZURE_CHINA_CLOUD
+    MsRestAzure::ActiveDirectoryServiceSettings.get_azure_china_settings
+  when ENVIRONMENT_AZURE_US_GOVERNMENT
+    MsRestAzure::ActiveDirectoryServiceSettings.get_azure_us_government_settings
+  when ENVIRONMENT_AZURE_GERMAN_CLOUD
+    MsRestAzure::ActiveDirectoryServiceSettings.get_azure_german_settings
+  else
+    MsRestAzure::ActiveDirectoryServiceSettings.get_azure_settings
+  end
+end
+
+def resource_manager_endpoint_url(environment = ENVIRONMENT_AZURE_CLOUD)
+  case environment
+  when ENVIRONMENT_AZURE_CHINA_CLOUD
+    MsRestAzure::AzureEnvironments::AzureChina.resource_manager_endpoint_url
+  when ENVIRONMENT_AZURE_US_GOVERNMENT
+    MsRestAzure::AzureEnvironments::AzureUSGovernment.resource_manager_endpoint_url
+  when ENVIRONMENT_AZURE_GERMAN_CLOUD
+    MsRestAzure::AzureEnvironments::AzureGermanCloud.resource_manager_endpoint_url
+  else
+    MsRestAzure::AzureEnvironments::Azure.resource_manager_endpoint_url
+  end
+end
+
+# storage_endpoint_suffix is nil in ms_rest_azure 0.6.2
+# Reference the issue: https://github.com/Azure/azure-sdk-for-ruby/issues/603
+def storage_endpoint_suffix(environment = ENVIRONMENT_AZURE_CLOUD)
+  case environment
+  when ENVIRONMENT_AZURE_CHINA_CLOUD
+    # MsRestAzure::AzureEnvironments::AzureChina.storage_endpoint_suffix
+    '.core.chinacloudapi.cn'
+  when ENVIRONMENT_AZURE_US_GOVERNMENT
+    # MsRestAzure::AzureEnvironments::AzureUSGovernment.storage_endpoint_suffix
+    '.core.usgovcloudapi.net'
+  when ENVIRONMENT_AZURE_GERMAN_CLOUD
+    # MsRestAzure::AzureEnvironments::AzureGermanCloud.storage_endpoint_suffix
+    '.core.cloudapi.de'
+  else
+    # MsRestAzure::AzureEnvironments::Azure.storage_endpoint_suffix
+    '.core.windows.net'
+  end
+end
+
+def get_blob_endpoint(storage_account_name, enable_https = false, environment = ENVIRONMENT_AZURE_CLOUD)
+  protocol = enable_https ? 'https' : 'http'
+  "#{protocol}://#{storage_account_name}.blob#{storage_endpoint_suffix(environment)}"
+end
+
+def current_time
+  time = Time.now.to_f.to_s
+  time.split(/\W+/).join
+end
+
+# Parse storage blob/container to a hash
+def parse_storage_object(object)
+  data = {}
+  if object.is_a? Hash
+    object.each do |k, v|
+      if k == 'properties'
+        v.each do |j, l|
+          data[j] = l
+        end
+      else
+        data[k] = v
+      end
+    end
+  else
+    object.instance_variables.each do |p|
+      kname = p.to_s.delete('@')
+      if kname == 'properties'
+        properties = object.instance_variable_get(p)
+        properties.each do |k, v|
+          data[k.to_s] = v
+        end
+      else
+        data[kname] = object.instance_variable_get(p)
+      end
+    end
+  end
+
+  data['last_modified'] = Time.parse(data['last_modified'])
+  data['etag'].delete!('"')
+  data
+end