fog-azure-rm 0.0.0

data/lib/fog/azurerm/models/resources/resource_group.rb

@@ -0,0 +1,21 @@
+module Fog
+  module Resources
+    class AzureRM
+      class ResourceGroup < Fog::Model
+        identity :name
+        attribute :id
+        attribute :location
+
+        def save
+          requires :name
+          requires :location
+          service.create_resource_group(name, location)
+        end
+
+        def destroy
+          service.delete_resource_group(name)
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/resources/resource_groups.rb

@@ -0,0 +1,28 @@
+require 'fog/core/collection'
+require 'fog/azurerm/models/resources/resource_group'
+
+module Fog
+  module Resources
+    class AzureRM
+      class ResourceGroups < Fog::Collection
+        model Fog::Resources::AzureRM::ResourceGroup
+
+        def all
+          resource_groups = []
+          service.list_resource_groups.each do |rg|
+            hash = {}
+            rg.instance_variables.each do |var|
+              hash[var.to_s.delete('@')] = rg.instance_variable_get(var)
+            end
+            resource_groups << hash
+          end
+          load(resource_groups)
+        end
+
+        def get(identity)
+          all.find { |f| f.name == identity }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# rubocop:disable LineLength
+# rubocop:disable MethodLength
+module Fog
+  module Storage
+    class AzureRM
+      # This class is giving implementation of create/save and
+      # delete/destroy for storage account.
+      class StorageAccount < Fog::Model
+        attribute :id
+        identity  :name
+        attribute :type
+        attribute :location
+        attribute :tags
+        attribute :resource_group
+        attribute :properties
+
+        def save
+          requires :name
+          requires :location
+          requires :resource_group
+          # Create a model for new storage account.
+          properties = Azure::ARM::Storage::Models::StorageAccountPropertiesCreateParameters.new
+          properties.account_type = 'Standard_LRS' # This might change in the near future!
+
+          params = Azure::ARM::Storage::Models::StorageAccountCreateParameters.new
+          params.properties = properties
+          params.location = location
+          service.create_storage_account(resource_group, name, params)
+        end
+
+        def destroy
+          service.delete_storage_account(resource_group, name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+require 'fog/core/collection'
+require 'fog/azurerm/models/storage/storage_account'
+# rubocop:disable LineLength
+# rubocop:disable MethodLength
+# rubocop:disable AbcSize
+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|
+            hash = {}
+            account.instance_variables.each do |var|
+              hash[var.to_s.delete('@')] = account.instance_variable_get(var)
+            end
+            accounts << hash
+          end
+          load(accounts)
+        end
+
+        def get(identity)
+          all.find { |f| f.name == identity }
+        end
+
+        def check_name_availability(name)
+          params = Azure::ARM::Storage::Models::StorageAccountCheckNameAvailabilityParameters.new
+          params.name = name
+          params.type = 'Microsoft.Storage/storageAccounts'
+          service.check_storage_account_name_availability(params)
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/network.rb

@@ -0,0 +1,67 @@
+require 'fog/azurerm/core'
+
+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
+
+      request_path 'fog/azurerm/requests/network'
+      request :create_virtual_network
+      request :delete_virtual_network
+      request :list_virtual_networks
+      request :check_for_virtual_network
+      request :create_public_ip
+      request :delete_public_ip
+      request :list_public_ips
+      request :check_for_public_ip
+      request :create_subnet
+      request :list_subnets
+      request :delete_subnet
+      request :create_network_interface
+      request :delete_network_interface
+      request :list_network_interfaces
+
+      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
+
+      # 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'
+          rescue LoadError => e
+            retry if require('rubygems')
+            raise e.message
+          end
+
+          credentials = Fog::Credentials::AzureRM.get_credentials(options[:tenant_id], options[:client_id], options[:client_secret])
+          @network_client = ::Azure::ARM::Network::NetworkManagementClient.new(credentials)
+          @network_client.subscription_id = options[:subscription_id]
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/compute/create_availability_set.rb

@@ -0,0 +1,45 @@
+# rubocop:disable AbcSize
+# rubocop:disable MethodLength
+module Fog
+  module Compute
+    class AzureRM
+      # This class provides the actual implemention for service calls.
+      class Real
+        def create_availability_set(resource_group, name, location)
+          begin
+            Fog::Logger.debug "Creating Availability Set '#{name}' in #{location} region."
+            avail_set_props = get_avail_set_properties(location)
+            promise = @compute_mgmt_client.availability_sets.create_or_update(resource_group, name, avail_set_props)
+            result = promise.value!
+            Fog::Logger.debug "Availability Set #{name} created successfully."
+            result
+          rescue MsRestAzure::AzureOperationError => e
+            msg = "Exception creating Availability Set #{name} in Resource Group: #{resource_group}. #{e.body['error']['message']}"
+            raise msg
+          end
+        end
+
+        # create the properties object for creating availability sets
+        def get_avail_set_properties(location)
+          avail_set_props =
+              Azure::ARM::Compute::Models::AvailabilitySetProperties.new
+          # At least two domain faults
+          avail_set_props.platform_fault_domain_count = 2
+          avail_set_props.platform_update_domain_count = 2
+          # At this point we do not have virtual machines to include
+          avail_set_props.virtual_machines = []
+          avail_set_props.statuses = []
+          avail_set = Azure::ARM::Compute::Models::AvailabilitySet.new
+          avail_set.location = location
+          avail_set.properties = avail_set_props
+          avail_set
+        end
+      end
+      # This class provides the mock implementation for unit tests.
+      class Mock
+        def create_availability_set(resource_group, name, params)
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/compute/create_virtual_machine.rb

@@ -0,0 +1,100 @@
+module Fog
+  module Compute
+    class AzureRM
+      # This class provides the actual implementation for service calls.
+      class Real
+        def create_virtual_machine(name, location, resource_group, vm_size, storage_account_name,
+                                   username, password, disable_password_authentication,
+                                   ssh_key_path, ssh_key_data, network_interface_card_id,
+                                   availability_set_id, publisher, offer, sku, version)
+          Fog::Logger.debug "Creating Virtual Machine #{name} in Resource Group #{resource_group}."
+          params = Azure::ARM::Compute::Models::VirtualMachine.new
+          vm_properties = Azure::ARM::Compute::Models::VirtualMachineProperties.new
+
+          unless availability_set_id.nil?
+            sub_resource = MsRestAzure::SubResource.new
+            sub_resource.id = availability_set_id
+            vm_properties.availability_set = sub_resource
+          end
+
+          vm_properties.hardware_profile = define_hardware_profile(vm_size)
+          vm_properties.storage_profile = define_storage_profile(name, storage_account_name, publisher, offer, sku, version)
+          vm_properties.os_profile = define_os_profile(name, username, password, disable_password_authentication, ssh_key_path, ssh_key_data)
+          vm_properties.network_profile = define_network_profile(network_interface_card_id)
+          params.properties = vm_properties
+          params.location = location
+          begin
+            promise = @compute_mgmt_client.virtual_machines.create_or_update(resource_group, name, params)
+            result = promise.value!
+            Fog::Logger.debug "Virtual Machine #{name} Created Successfully."
+            Azure::ARM::Compute::Models::VirtualMachine.serialize_object(result.body)
+          rescue MsRestAzure::AzureOperationError => e
+            msg = "Error Creating Virtual Machine '#{name}' in Resource Group '#{resource_group}'. #{e.body['error']['message']}"
+            raise msg
+          end
+        end
+
+        private
+
+        def define_hardware_profile(vm_size)
+          hw_profile =  Azure::ARM::Compute::Models::HardwareProfile.new
+          hw_profile.vm_size = vm_size
+          hw_profile
+        end
+
+        def define_storage_profile(vm_name, storage_account_name, publisher, offer, sku, version)
+          storage_profile = Azure::ARM::Compute::Models::StorageProfile.new
+          os_disk = Azure::ARM::Compute::Models::OSDisk.new
+          vhd = Azure::ARM::Compute::Models::VirtualHardDisk.new
+          image_reference = Azure::ARM::Compute::Models::ImageReference.new
+
+          image_reference.publisher = publisher
+          image_reference.offer = offer
+          image_reference.sku = sku
+          image_reference.version = version
+          vhd.uri = "http://#{storage_account_name}.blob.core.windows.net/vhds/#{vm_name}_os_disk.vhd"
+          os_disk.name = "#{vm_name}_os_disk"
+          os_disk.vhd = vhd
+          os_disk.create_option = Azure::ARM::Compute::Models::DiskCreateOptionTypes::FromImage
+          storage_profile.image_reference = image_reference
+          storage_profile.os_disk = os_disk
+          storage_profile
+        end
+
+        def define_os_profile(vm_name, username, password, disable_password_authentication, ssh_key_path, ssh_key_data)
+          os_profile = Azure::ARM::Compute::Models::OSProfile.new
+          linux_config = Azure::ARM::Compute::Models::LinuxConfiguration.new
+
+          unless ssh_key_path.nil? || ssh_key_data.nil?
+            ssh_config = Azure::ARM::Compute::Models::SshConfiguration.new
+            ssh_public_key = Azure::ARM::Compute::Models::SshPublicKey.new
+            ssh_public_key.path = ssh_key_path
+            ssh_public_key.key_data = ssh_key_data
+            ssh_config.public_keys = [ssh_public_key]
+            linux_config.ssh = ssh_config
+          end
+
+          linux_config.disable_password_authentication = disable_password_authentication
+          os_profile.linux_configuration = linux_config
+          os_profile.computer_name = vm_name
+          os_profile.admin_username = username
+          os_profile.admin_password = password
+          os_profile
+        end
+
+        def define_network_profile(network_interface_card_id)
+          network_profile = Azure::ARM::Compute::Models::NetworkProfile.new
+          nic = Azure::ARM::Compute::Models::NetworkInterfaceReference .new
+          nic.id = network_interface_card_id
+          network_profile.network_interfaces = [nic]
+          network_profile
+        end
+      end
+      # This class provides the mock implementation for unit tests.
+      class Mock
+        def create_virtual_machine
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/compute/deallocate_virtual_machine.rb

@@ -0,0 +1,26 @@
+module Fog
+  module Compute
+    class AzureRM
+      # This class provides the actual implemention for service calls.
+      class Real
+        def deallocate_virtual_machine(resource_group, name)
+          Fog::Logger.debug "Deallocating Virtual Machine #{name} in Resource Group #{resource_group}."
+          begin
+            promise = @compute_mgmt_client.virtual_machines.deallocate(resource_group, name)
+            result = promise.value!
+            Fog::Logger.debug "Virtual Machine #{name} Deallocated Successfully."
+            result
+          rescue  MsRestAzure::AzureOperationError => e
+            msg = "Error Deallocating Virtual Machine '#{name}' in Resource Group '#{resource_group}'. #{e.body['error']['message']}"
+            raise msg
+          end
+        end
+      end
+      # This class provides the mock implementation for unit tests.
+      class Mock
+        def deallocate_virtual_machine(resource_group, name)
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/compute/delete_availability_set.rb

@@ -0,0 +1,26 @@
+module Fog
+  module Compute
+    class AzureRM
+      # This class provides the actual implemention for service calls.
+      class Real
+        def delete_availability_set(resource_group, name)
+          begin
+            Fog::Logger.debug "Deleting Availability Set: #{name}."
+            promise = @compute_mgmt_client.availability_sets.delete(resource_group, name)
+            result = promise.value!
+            Fog::Logger.debug "Availability Set #{name} deleted successfully."
+            result
+          rescue MsRestAzure::AzureOperationError => e
+            msg = "Exception deleting Availability Set #{name} in Resourse Group #{resource_group}. #{e.body['error']['message']}"
+            raise msg
+          end
+        end
+      end
+      # This class provides the mock implementation for unit tests.
+      class Mock
+        def delete_availability_set(resource_group, name)
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/compute/delete_virtual_machine.rb

@@ -0,0 +1,26 @@
+module Fog
+  module Compute
+    class AzureRM
+      # This class provides the actual implemention for service calls.
+      class Real
+        def delete_virtual_machine(resource_group, name)
+          Fog::Logger.debug "Deleting Virtual Machine #{name} from Resource Group #{resource_group}."
+          begin
+            promise = @compute_mgmt_client.virtual_machines.delete(resource_group, name)
+            result = promise.value!
+            Fog::Logger.debug "Virtual Machine #{name} Deleted Successfully."
+            result
+          rescue  MsRestAzure::AzureOperationError => e
+            msg = "Error Deleting Virtual Machine '#{name}' from Resource Group '#{resource_group}'. #{e.body['error']['message']}"
+            raise msg
+          end
+        end
+      end
+      # This class provides the mock implementation for unit tests.
+      class Mock
+        def delete_virtual_machine(resource_group, name)
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/compute/generalize_virtual_machine.rb

@@ -0,0 +1,26 @@
+module Fog
+  module Compute
+    class AzureRM
+      # This class provides the actual implemention for service calls.
+      class Real
+        def generalize_virtual_machine(resource_group, name)
+          Fog::Logger.debug "Generalizing Virtual Machine #{name} in Resource Group #{resource_group}."
+          begin
+            promise = @compute_mgmt_client.virtual_machines.generalize(resource_group, name)
+            result = promise.value!
+            Fog::Logger.debug "Virtual Machine #{name} Generalized Successfully."
+            result
+          rescue  MsRestAzure::AzureOperationError => e
+            msg = "Error Generalizing Virtual Machine '#{name}' in Resource Group '#{resource_group}'. #{e.body['error']['message']}"
+            raise msg
+          end
+        end
+      end
+      # This class provides the mock implementation for unit tests.
+      class Mock
+        def generalize_virtual_machine(resource_group, name)
+        end
+      end
+    end
+  end
+end