far-gem 0.5.1

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

@@ -0,0 +1,76 @@
+module Fog
+  module Compute
+    class AzureRM
+      # This class is giving implementation For Virtual Machine Extension
+      class VirtualMachineExtension < Fog::Model
+        identity :name
+        attribute :id
+        attribute :resource_group
+        attribute :location
+        attribute :vm_name
+        attribute :type
+        attribute :publisher
+        attribute :type_handler_version
+        attribute :auto_upgrade_minor_version
+        attribute :settings
+        attribute :protected_settings
+
+        def self.parse(vm_extension)
+          virtual_machine_extension = {}
+          virtual_machine_extension[:id] = vm_extension.id
+          virtual_machine_extension[:resource_group] = get_resource_group_from_id(vm_extension.id)
+          virtual_machine_extension[:name] = vm_extension.name
+          virtual_machine_extension[:location] = vm_extension.location
+          virtual_machine_extension[:vm_name] = get_virtual_machine_from_id(vm_extension.id)
+          virtual_machine_extension[:type] = vm_extension.virtual_machine_extension_type
+          virtual_machine_extension[:publisher] = vm_extension.publisher
+          virtual_machine_extension[:type_handler_version] = vm_extension.type_handler_version
+          virtual_machine_extension[:auto_upgrade_minor_version] = vm_extension.auto_upgrade_minor_version
+          virtual_machine_extension[:settings] = vm_extension.settings
+          virtual_machine_extension[:protected_settings] = vm_extension.protected_settings
+          virtual_machine_extension
+        end
+
+        def save
+          requires :resource_group, :location, :name, :vm_name, :type, :publisher, :type_handler_version, :settings
+          vm_extension = service.create_or_update_vm_extension(vm_extension_params)
+          merge_attributes(Fog::Compute::AzureRM::VirtualMachineExtension.parse(vm_extension))
+        end
+
+        def update(vm_extension_input)
+          validate_input(vm_extension_input)
+          merge_attributes(vm_extension_input) unless vm_extension_input.empty?
+          vm_extension = service.create_or_update_vm_extension(vm_extension_params)
+          merge_attributes(Fog::Compute::AzureRM::VirtualMachineExtension.parse(vm_extension))
+        end
+
+        def destroy
+          service.delete_vm_extension(resource_group, vm_name, name)
+        end
+
+        private
+
+        def validate_input(vm_extension_input)
+          invalid_attr = [:id, :resource_group, :location, :name, :vm_name, :type, :publisher]
+          result = invalid_attr & vm_extension_input.keys
+          raise 'Cannot modify the given attribute(s)' unless result.empty?
+        end
+
+        def vm_extension_params
+          {
+            resource_group: resource_group,
+            location: location,
+            name: name,
+            vm_name: vm_name,
+            type: type,
+            publisher: publisher,
+            type_handler_version: type_handler_version,
+            auto_upgrade_minor_version: auto_upgrade_minor_version,
+            settings: settings,
+            protected_settings: protected_settings
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Fog
+  module Compute
+    class AzureRM
+      # This class gives the implementation for get for virtual machine extension
+      class VirtualMachineExtensions < Fog::Collection
+        model Fog::Compute::AzureRM::VirtualMachineExtension
+        attribute :resource_group
+        attribute :vm_name
+
+        def all
+          requires :resource_group, :vm_name
+          vm_extensions = []
+          service.get_virtual_machine(resource_group, vm_name).resources.compact.each do |extension|
+            vm_extensions << Fog::Compute::AzureRM::VirtualMachineExtension.parse(extension)
+          end
+          load(vm_extensions)
+        end
+
+        def get(resource_group_name, virtual_machine_name, vm_extension_name)
+          vm_extension = service.get_vm_extension(resource_group_name, virtual_machine_name, vm_extension_name)
+          vm_extension_fog = Fog::Compute::AzureRM::VirtualMachineExtension.new(service: service)
+          vm_extension_fog.merge_attributes(Fog::Compute::AzureRM::VirtualMachineExtension.parse(vm_extension))
+        end
+
+        def check_vm_extension_exists(resource_group_name, virtual_machine_name, vm_extension_name)
+          service.check_vm_extension_exists(resource_group_name, virtual_machine_name, vm_extension_name)
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/dns/a_record.rb

@@ -0,0 +1,15 @@
+module Fog
+  module DNS
+    class AzureRM
+      # This class is giving an implementation of 'A' RecordSet type
+      class ARecord < Fog::Model
+        attribute :ipv4address
+
+        def self.parse(arecord)
+          hash = get_hash_from_object(arecord)
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/dns/cname_record.rb

@@ -0,0 +1,15 @@
+module Fog
+  module DNS
+    class AzureRM
+      # This class is giving an implementation of 'CNAME' RecordSet type
+      class CnameRecord < Fog::Model
+        attribute :cname
+
+        def self.parse(cnamerecord)
+          hash = get_hash_from_object(cnamerecord)
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/dns/record_set.rb

@@ -0,0 +1,103 @@
+module Fog
+  module DNS
+    class AzureRM
+      # This class is giving implementation of create/save and
+      # delete/destroy for RecordSet.
+      class RecordSet < Fog::Model
+        attribute :id
+        identity :name
+        attribute :resource_group
+        attribute :zone_name
+        attribute :records
+        attribute :type
+        attribute :ttl
+        attribute :cname_record
+        attribute :a_records
+
+        def self.parse(recordset)
+          hash = get_hash_from_object(recordset)
+          hash['resource_group'] = get_resource_group_from_id(recordset.id)
+          hash['zone_name'] = get_record_set_from_id(recordset.id)
+          type = get_type_from_recordset_type(recordset.type)
+
+          hash['records'] = []
+          if type == 'A'
+            record_entries = recordset.arecords
+            record_entries.each do |record|
+              hash['records'] << record.ipv4address
+            end
+          end
+          if type == 'CNAME'
+            record_entries = recordset.cname_record
+            hash['records'] << record_entries.cname
+          end
+
+          unless recordset.arecords.nil?
+            a_records = []
+            recordset.arecords.each do |record|
+              a_record = Fog::DNS::AzureRM::ARecord.new
+              a_record.merge_attributes(Fog::DNS::AzureRM::ARecord.parse(record))
+              a_records.push(a_record)
+            end
+            hash['a_records'] = a_records
+          end
+
+          unless recordset.cname_record.nil?
+            cname_record = Fog::DNS::AzureRM::CnameRecord.new
+            cname_record.merge_attributes(Fog::DNS::AzureRM::CnameRecord.parse(recordset.cname_record))
+            hash['cname_record'] = cname_record
+          end
+
+          hash
+        end
+
+        def save
+          requires :name, :resource_group, :zone_name, :records, :type, :ttl
+          record_set = service.create_or_update_record_set(record_set_params, type)
+          merge_attributes(Fog::DNS::AzureRM::RecordSet.parse(record_set))
+        end
+
+        def destroy
+          service.delete_record_set(resource_group, name, zone_name, get_record_type(type))
+        end
+
+        def get_records(resource_group, name, zone_name, record_type)
+          service.get_records_from_record_set(resource_group, name, zone_name, record_type)
+        end
+
+        def update_ttl(ttl)
+          params = record_set_params
+          params[:ttl] = ttl
+          record_set = service.create_or_update_record_set(params, get_record_type(type))
+          merge_attributes(Fog::DNS::AzureRM::RecordSet.parse(record_set))
+        end
+
+        def add_a_type_record(record)
+          records << record
+          record_set = service.create_or_update_record_set(record_set_params, get_record_type(type))
+          merge_attributes(Fog::DNS::AzureRM::RecordSet.parse(record_set))
+        end
+
+        def remove_a_type_record(record)
+          records.delete(record)
+          record_set = service.create_or_update_record_set(record_set_params, get_record_type(type))
+          merge_attributes(Fog::DNS::AzureRM::RecordSet.parse(record_set))
+        end
+
+        private
+
+        def record_set_params
+          {
+            name: name,
+            resource_group: resource_group,
+            zone_name: zone_name,
+            records: records,
+            ttl: ttl,
+            cname_record: cname_record,
+            a_records: a_records
+          }
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/dns/record_sets.rb

@@ -0,0 +1,34 @@
+module Fog
+  module DNS
+    class AzureRM
+      # This class is giving implementation of
+      # all/get for RecordSets.
+      class RecordSets < Fog::Collection
+        attribute :resource_group
+        attribute :zone_name
+        attribute :type
+
+        model Fog::DNS::AzureRM::RecordSet
+
+        def all
+          requires :resource_group, :zone_name
+          record_sets = []
+          service.list_record_sets(resource_group, zone_name).each do |r|
+            record_sets << Fog::DNS::AzureRM::RecordSet.parse(r)
+          end
+          load(record_sets)
+        end
+
+        def get(resource_group, name, zone_name, record_type)
+          record_set = service.get_record_set(resource_group, name, zone_name, record_type)
+          record_set_fog = Fog::DNS::AzureRM::RecordSet.new(service: service)
+          record_set_fog.merge_attributes(Fog::DNS::AzureRM::RecordSet.parse(record_set))
+        end
+
+        def check_record_set_exists(resource_group, name, zone_name, record_type)
+          service.check_record_set_exists(resource_group, name, zone_name, record_type)
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/dns/zone.rb

@@ -0,0 +1,58 @@
+module Fog
+  module DNS
+    class AzureRM
+      # This class is giving implementation of create/save and
+      # delete/destroy for Zone.
+      class Zone < Fog::Model
+        attribute :id
+        identity :name
+        attribute :resource_group
+        attribute :location
+        attribute :type
+        attribute :tags
+        attribute :etag
+        attribute :number_of_record_sets
+        attribute :max_number_of_record_sets
+
+        def self.parse(zone)
+          hash = {}
+          hash['id'] = zone.id
+          hash['name'] = zone.name
+          hash['resource_group'] = get_resource_group_from_id(zone.id)
+          hash['location'] = zone.location
+          hash['type'] = zone.type
+          hash['tags'] = zone.tags
+          hash['etag'] = zone.etag
+          hash['number_of_record_sets'] = zone.number_of_record_sets
+          hash['max_number_of_record_sets'] = zone.max_number_of_record_sets
+          hash
+        end
+
+        def save
+          requires :name, :resource_group, :location
+          zone = service.create_or_update_zone(zone_params)
+          merge_attributes(Fog::DNS::AzureRM::Zone.parse(zone))
+        end
+
+        def destroy
+          service.delete_zone(resource_group, name)
+        end
+
+        private
+
+        def zone_params
+          {
+            name: name,
+            resource_group: resource_group,
+            location: location,
+            type: type,
+            tags: tags,
+            number_of_record_sets: number_of_record_sets,
+            max_number_of_record_sets: max_number_of_record_sets,
+            etag: etag
+          }
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/dns/zones.rb

@@ -0,0 +1,29 @@
+module Fog
+  module DNS
+    class AzureRM
+      # This class is giving implementation of
+      # all/get for Zones.
+      class Zones < Fog::Collection
+        model Fog::DNS::AzureRM::Zone
+
+        def all
+          zones = []
+          service.list_zones.each do |z|
+            zones << Fog::DNS::AzureRM::Zone.parse(z)
+          end
+          load(zones)
+        end
+
+        def get(resource_group, name)
+          zone = service.get_zone(resource_group, name)
+          zone_fog = Fog::DNS::AzureRM::Zone.new(service: service)
+          zone_fog.merge_attributes(Fog::DNS::AzureRM::Zone.parse(zone))
+        end
+
+        def check_zone_exists(resource_group, name)
+          service.check_zone_exists(resource_group, name)
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/key_vault/access_policy_entry.rb

@@ -0,0 +1,27 @@
+module Fog
+  module KeyVault
+    class AzureRM
+      # AccessPolicyEntry Model for Storage Service
+      class AccessPolicyEntry < Fog::Model
+        identity  :object_id
+        attribute :tenant_id
+        attribute :application_id
+        attribute :keys
+        attribute :secrets
+        attribute :certificates
+
+        def self.parse(access_policy_entry)
+          access_policy_entry_hash = get_hash_from_object(access_policy_entry)
+          permissions = access_policy_entry.permissions
+          unless permissions.nil?
+            access_policy_entry_hash['keys'] = permissions.keys
+            access_policy_entry_hash['secrets'] = permissions.secrets
+            access_policy_entry_hash['certificates'] = permissions.certificates
+          end
+
+          access_policy_entry_hash
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/key_vault/vault.rb

@@ -0,0 +1,78 @@
+module Fog
+  module KeyVault
+    class AzureRM
+      # Vault model for KeyVault Service
+      class Vault < Fog::Model
+        identity :name
+        attribute :id
+        attribute :resource_group
+        attribute :location
+        attribute :vault_uri
+        attribute :tenant_id
+        attribute :sku_family
+        attribute :sku_name
+        attribute :access_policies
+        attribute :enabled_for_deployment
+        attribute :enabled_for_disk_encryption
+        attribute :enabled_for_template_deployment
+        attribute :tags
+
+        def self.parse(vault)
+          vault_hash = get_hash_from_object(vault)
+          vault_properties = vault.properties
+
+          unless vault_properties.nil?
+            vault_hash['vault_uri'] = vault_properties.vault_uri
+            vault_hash['tenant_id'] = vault_properties.tenant_id
+
+            unless vault_properties.sku.nil?
+              vault_hash['sku_family'] = vault_properties.sku.family
+              vault_hash['sku_name'] = vault_properties.sku.name
+            end
+
+            vault_hash['access_policies'] = []
+            unless vault_properties.access_policies.nil?
+              vault_properties.access_policies.each do |access_policy|
+                access_policy_entry = Fog::KeyVault::AzureRM::AccessPolicyEntry.new
+                vault_hash['access_policies'] << access_policy_entry.merge_attributes(Fog::KeyVault::AzureRM::AccessPolicyEntry.parse(access_policy))
+              end
+            end
+
+            vault_hash['enabled_for_deployment'] = vault_properties.enabled_for_deployment
+            vault_hash['enabled_for_disk_encryption'] = vault_properties.enabled_for_disk_encryption
+            vault_hash['enabled_for_template_deployment'] = vault_properties.enabled_for_template_deployment
+
+            vault_hash['resource_group'] = get_resource_group_from_id(vault.id)
+          end
+
+          vault_hash
+        end
+
+        def save
+          requires :name, :resource_group, :location, :tenant_id, :sku_family, :sku_name, :access_policies
+          vault = service.create_or_update_vault(vault_hash)
+          merge_attributes(Fog::KeyVault::AzureRM::Vault.parse(vault))
+        end
+
+        def destroy
+          service.delete_vault(resource_group, name)
+        end
+
+        private
+
+        def vault_hash
+          {
+            resource_group: resource_group,
+            name: name,
+            location: location,
+            tenant_id: tenant_id,
+            sku_family: sku_family,
+            sku_name: sku_name,
+            access_policies: access_policies,
+            tags: tags
+          }
+        end
+      end
+    end
+  end
+end