fog-azure-rm 0.0.6 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 17db5794c8186b1a029c4bae7d938443d2392db2
-  data.tar.gz: 19682802907daf630ab3bd1ad6ce6a0d88cbf678
+  metadata.gz: 4b685851346e42d9a032133a02a6c3a12ccf5896
+  data.tar.gz: f018a73de0ea3dcec83d57c9f355b0b76571fded
 SHA512:
-  metadata.gz: c23376452f1441ef55a1e9a7eff0dbecc2daa024e689151b7db49ee27b44fe35dd90cbd8e5df7c253baae0cad07923298043430baa64a188b7fef9a6e912d1ca
-  data.tar.gz: b2ab099ace9089b714a1318bb56603a9b4fee9ba9e7abf76fde9e1c2164aa32f1feff1d2f74d2ba5b5c511336eb8784122762e26313d859a5ef701f8ad0c5ef0
+  metadata.gz: 42f964d72836337a5057cacf99ce98c144e62e99461ab1fe00e92c9ac83d291b7e8c6a465babc116481894d221c8ed65f70396ecb18b69c688fb5e96e7feab89
+  data.tar.gz: afcd011ce4a78237e5515eba3ff43559bfa77c9cf5b539367ad54fb33d2d893b533768f40d6b7ef89668b03a93cd87118dcec079518aad7cfc59ca22410c5f7a

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+## 0.0.7 
+
+**Added:**
+- Compute Service - Added support to create virtual machine from a custom image.
+- Network Service - Added Network Security Rule.
+- Network Service - Added Get Available IP Addresses count in Subnet
+- Compute Service - Virtual Machine Extension
+- Added Blob count, blob exist, blob compare,blob copy, lease blob, release lease blob, delete blob, set blob properties,
+    get blob properties, set blob metadata, get blob metadata, get blob, list blob functionality for storage
+- Added get container properties, get container metadata, set container metadata, get container, list container,
+    delete container,  Get the access control list of the container
+
+
 ## 0.0.6
 
 **Added:**

data/lib/fog/azurerm/compute.rb

@@ -26,12 +26,17 @@ module Fog
       request :check_vm_status
       request :attach_data_disk_to_vm
       request :detach_data_disk_from_vm
+      request :create_or_update_vm_extension
+      request :delete_vm_extension
+      request :get_vm_extension
 
       model_path 'fog/azurerm/models/compute'
       model :availability_set
       collection :availability_sets
       model :server
       collection :servers
+      model :virtual_machine_extension
+      collection :virtual_machine_extensions
 
       # This class provides the mock implementation for unit tests.
       class Mock
@@ -61,6 +66,7 @@ module Fog
           @compute_mgmt_client.subscription_id = options[:subscription_id]
           @storage_mgmt_client = ::Azure::ARM::Storage::StorageManagementClient.new(credentials)
           @storage_mgmt_client.subscription_id = options[:subscription_id]
+          @storage_service = Fog::Storage::AzureRM.new(tenant_id: options[:tenant_id], client_id: options[:client_id], client_secret: options[:client_secret], subscription_id: options[:subscription_id])
         end
       end
     end

data/lib/fog/azurerm/docs/compute.md

@@ -39,14 +39,16 @@ Create a new linux server
         password: '<Password for VM>',
         disable_password_authentication: false,
         network_interface_card_id: '/subscriptions/{Subscription-Id}/resourceGroups/{Resource-Group-Name}/providers/Microsoft.Network/networkInterfaces/{Network-Interface-Id}',
-        publisher: 'Canonical',
-        offer: 'UbuntuServer',
-        sku: '14.04.2-LTS',
-        version: 'latest',
+        publisher: 'Canonical',                    # Not required if custom image is being used 
+        offer: 'UbuntuServer',                     # Not required if custom image is being used
+        sku: '14.04.2-LTS',                        # Not required if custom image is being used
+        version: 'latest',                         # Not required if custom image is being used
         platform: 'Linux',
-        custom_data: 'echo customData'            # Optional
+        vhd_path: '<Path of VHD>',                 # Optional, if you want to create the VM from a custom image.
+        custom_data: 'echo customData',            # Optional, if you want to add custom data in this VM.
     )
 ```
+
 Create a new windows server
 
 ```ruby
@@ -60,14 +62,16 @@ Create a new windows server
         password: '<Password for VM>',
         disable_password_authentication: false,
         network_interface_card_id: '/subscriptions/{Subscription-Id}/resourceGroups/{Resource-Group-Name}/providers/Microsoft.Network/networkInterfaces/{Network-Interface-Id}',
-        publisher: 'MicrosoftWindowsServerEssentials',
-        offer: 'WindowsServerEssentials',
-        sku: 'WindowsServerEssentials',
-        version: 'latest',
+        publisher: 'MicrosoftWindowsServerEssentials',   # Not required if custom image is being used
+        offer: 'WindowsServerEssentials',                # Not required if custom image is being used  
+        sku: 'WindowsServerEssentials',                  # Not required if custom image is being used
+        version: 'latest',                               # Not required if custom image is being used
         platform: 'Windows',
-        custom_data: 'echo customData'            # Optional
+        vhd_path: '<Path of VHD>',                       # Optional, if you want to create the VM from a custom image.
+        custom_data: 'echo customData'                   # Optional, if you want to add custom data in this VM.
     )
 ```
+ 
 For more information about custom_data; see link: https://msdn.microsoft.com/en-us/library/azure/mt163591.aspx
 
 ## List Servers
@@ -98,7 +102,7 @@ Get a single record of Server
 Get the server object and attach a Data Disk to it.
 
 ```ruby
-      server.attach_data_disk('<Disk Name>', <Size in GB>, '<Storage Account Name>)
+      server.attach_data_disk('<Disk Name>', <Size in GB>, '<Storage Account Name>')
 ```
 
 ## Detach a Data Disk from Server
@@ -171,5 +175,57 @@ Get an availability set object from the get method and then destroy that availab
       availability_set.destroy
 ```
 
+## Create Virtual Machine Extension
+
+Installs an extension to the specified virtual machine.
+
+```ruby
+    azure_compute_service.virtual_machine_extensions.create(
+        name: <Extension Name>,
+        resource_group: <Resource Group>,
+        location: <Location>,
+        vm_name: <Virtual Machine Name>, # Extension will be installed on this VM
+        publisher: <Extension publisher>,
+        type: <Extension type>,
+        type_handler_version: <Extension version>,
+        auto_upgrade_minor_version: <true|false>, # Optional
+        settings: {JSON object}, # Format: {"key": "value", "key": {"key": "value"}}
+        protected_settings: {JSON object}
+    )
+```
+
+## Get Extension from Virtual Machine
+
+Retrieves the given extension from the virtual machine
+
+```ruby
+    vm_extension = azure_compute_service.virtual_machine_extensions.get(
+        '<Resource Group Name>', '<Virtual Machine Name>', '<Extension Name>'
+    )
+```
+
+## Update Extension
+
+Update the given extension. The attributes that can be modified are
+- auto_upgrade_minor_version
+- settings
+- protected_settings
+
+```ruby
+    vm_extension.update(
+        auto_upgrade_minor_version: <true|false>,
+        settings: {JSON object},
+        protected_settings: {JSON object}
+    )
+```
+
+## Destroy Extension
+
+Destroy the given extension from the virtual machine
+
+```ruby
+    vm_extension.destroy
+```
+
 ## Support and Feedback
 Your feedback is appreciated! If you have specific issues with the fog ARM, you should file an issue via Github.

data/lib/fog/azurerm/docs/network.md

@@ -201,6 +201,14 @@ Detach Route Table from Subnet
      puts "#{subnet.route_table_id}"
 ```
 
+## List Number of Available IP Addresses in Subnet
+
+The parameter is a boolean which checks if the Virtual Network the Subnet belongs to is attached to an Express Route Circuit or not
+
+```ruby
+    puts "#{subnet.get_available_ipaddresses_count(false)}"
+```
+
 ## Destroy a single Subnet
 
 Get a subnet object from the get method and then destroy that subnet.
@@ -454,6 +462,57 @@ Get a network security group object from the get method and then destroy that ne
     nsg.destroy
 ```
 
+## Create Network Security Rule
+
+Network security rule requires a resource group and network security group to create. 
+
+```ruby
+     azure_network_service.network_security_rules.create(
+       name: '<Security Rule name>',
+       resource_group: '<Resource Group name>',
+       protocol: 'tcp',
+       network_security_group_name: '<Network Security Group name>',
+       source_port_range: '22',
+       destination_port_range: '22',
+       source_address_prefix: '0.0.0.0/0',
+       destination_address_prefix: '0.0.0.0/0',
+       access: 'Allow',
+       priority: '100',
+       direction: 'Inbound'
+     )
+```
+
+## List Network Security Rules 
+
+List all the network security rules in a resource group and network security group
+
+```ruby
+    network_security_rules = azure_network_service.network_security_rules(resource_group: '<Resource Group name>',
+                                                            network_security_group_name: '<Network Security Group name>')
+    network_security_rules.each do |network_security_rule|
+      puts network_security_rule.name
+    end
+```
+
+## Retrieve a single Network Security Rule
+
+Get a single record of Network Security Rule
+
+```ruby
+    network_security_rule = azure_network_service
+                  .network_security_rules
+                  .get(<Resource Group Name>','<Network Security Group name>', '<Security Rule name>')
+    puts "#{network_security_rule.name}"              
+```
+
+## Destroy a Network Security Rule
+
+Get a network security rule object from the get method and then destroy that network security rule.
+
+```ruby
+    network_security_rule.destroy
+```
+
 ## Create External Load Balancer
 
 Create a new load balancer.

data/lib/fog/azurerm/docs/storage.md

@@ -55,7 +55,7 @@ azure_storage_service = Fog::Storage.new(
 Check Storage Account Name Availability.This operation checks that account name is valid and is not already in use.
 
 ```ruby
-    azure_storage_service.storage_accounts.check_name_availability('<Storage Account name>')
+azure_storage_service.storage_accounts.check_name_availability('<Storage Account name>')
 ```
 
 ## Create Storage Account
@@ -153,77 +153,149 @@ puts "#{container.name}"
 List all the storage containers in the current storage accounts.
 
 ```ruby
-azure_storage_service.containers.each do |container|
-  puts "#{container.name}"
+azure_storage_service.directories.each do |directory|
+  puts "#{directory.name}"
 end
 ```
 
-## Get storage container properties
+## Get the access control list of the storage container
+
+Get the permissions for the specified container. The permissions indicate whether container data may be accessed publicly.
+
+```ruby
+directory = azure_storage_service.directories.get('<container name>')
+access_control_list = directory.get_access_control_list('<container name>')
+puts "#{access_control_list.inspect}"
+```
+
+## Delete the storage container
+
+Mark the specified container for deletion. The container and any blobs contained within it are later deleted during garbage collection.
+
+```ruby
+directory = azure_storage_service.directories.get('<container name>')
+result = directory.destroy
+puts "#{result}"
+```
+
+## Upload a local file as a blob
+```ruby
+new_cloud_file = azure_storage_service.files.get('<Container name>', '<Blob name>').create(file_path: '<file path>')
+puts "#{new_cloud_file.inspect}"
+```
+
+## Copy Blob from one container to another
+```ruby
+puts storage_data.copy_blob('<destination_container_name>', '<destination_blob_name>', '<source_container_name>', '<source_blob_name>')
+```
+
+## Download a blob to a local file
+```ruby
+blob = azure_storage_service.files.get('<Container name>', '<Blob name>').save_to_file('<file path>')
+puts "#{blob.inspect}"
+puts "File Size: #{::File.size <file_path>}"
+```
+
+## Delete the storage blob
+
+Mark the specified blob for deletion. The blob is later deleted during garbage collection.
+
+```ruby
+cloud_file = azure_storage_service.files.get('<container name>', '<blob name>')
+result = cloud_file.destroy
+puts "#{result}"
+```
+
+Note that in order to delete a blob, you must delete all of its snapshots.
+
+```ruby
+cloud_file = azure_storage_service.files.get('<container name>', '<blob name>')
+result = cloud_file.destroy(delete_snapshots: 'only')
+puts "#{result}"
+
+result = cloud_file.destroy
+puts "#{result}"
+```
+
+You can delete both at the same time by specifying the option.
+
+```ruby
+cloud_file = azure_storage_service.files.get('<container name>', '<blob name>')
+result = cloud_file.destroy(delete_snapshots: 'inlcude')
+puts "#{result}"
+```
+
+## Properties
+
+### Get storage container properties
 
 Get the storage container properties. The properties will not fetch the access control list. Call `get_container_access_control_list` to fetch it.
 
 ```ruby
-container = azure_storage_service.containers.get('<container name>')
-properties = container.get_properties
+directory = azure_storage_service.directories.get('<container name>')
+properties = directory.get_properties
 puts "#{properties.inspect}"
 ```
 
-## Get the access control list of the storage container
+### Get storage blob properties
 
-Get the permissions for the specified container. The permissions indicate whether container data may be accessed publicly.
+Get the storage blob properties.
 
 ```ruby
-container = azure_storage_service.containers.get('<container name>')
-access_control_list = container.get_access_control_list('<container name>')
-puts "#{access_control_list.inspect}"
+cloud_file = azure_storage_service.files.get('<container name>', '<blob name>')
+properties = cloud_file.get_properties
+puts "#{properties.inspect}"
 ```
 
-## Delete the storage container
+### Set storage blob properties
 
-Mark the specified container for deletion. The container and any blobs contained within it are later deleted during garbage collection.
+Set the storage blob properties. The properties are passed in name/value pairs.
 
 ```ruby
-container = azure_storage_service.containers.get('<container name>')
-result = container.destroy
-puts "#{result}"
+cloud_file = azure_storage_service.files.get('<container name>', '<blob name>')
+properties = {
+  "content_language" => "English",
+  "content_disposition" => "attachment"
+}
+cloud_file.set_properties(properties)
 ```
 
-### Metadata
+## Metadata
 
 Metadata allows us to provide descriptive information about specific containers or blobs. This is simply providing name/value pairs of data we want to set on the container or blob.
 
-## Get Blob Metadata
+### Get Blob Metadata
 
 ```ruby
-      azure_storage_service.blobs.get_blob_metadata('<Container name>', '<Blob name>')
+azure_storage_service.files.get('<Container name>', '<Blob name>').get_metadata
 ```
 
-## Set Blob Metadata
+### Set Blob Metadata
 
 ```ruby
-      metadata = {
-        "Category" => "Images",
-        "Resolution" => "High"
-      }
-      azure_storage_service.blobs.set_blob_metadata('<Container name>', '<Blob name>', metadata)
+metadata = {
+  "Category" => "Images",
+  "Resolution" => "High"
+}
+azure_storage_service.files.get('<Container name>', '<Blob name>').set_metadata(metadata)
 ```
 
-## Get Container Metadata
+### Get Container Metadata
 
 ```ruby
-      azure_storage_service.containers.get_container_metadata('<Container name>')
+azure_storage_service.directories.get_metadata('<Container name>')
 ```
 
-## Set Container Metadata
+### Set Container Metadata
 
 ```ruby
-      metadata = {
-        "CreatedBy" => "User",
-        "SourceMachine" => "Mymachine",
-        "category" => "guidance",
-        "docType" => "textDocuments"
-       }
-      azure_storage_service.containers.set_container_metadata('<Container name>', metadata)
+metadata = {
+  "CreatedBy" => "User",
+  "SourceMachine" => "Mymachine",
+  "category" => "guidance",
+  "docType" => "textDocuments"
+  }
+azure_storage_service.directories.set_metadata('<Container name>', metadata)
 ```
 
 ## Support and Feedback

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

@@ -29,6 +29,7 @@ module Fog
         attribute :network_interface_card_id
         attribute :availability_set_id
         attribute :custom_data
+        attribute :vhd_path
 
         def self.parse(vm)
           hash = {}
@@ -39,10 +40,12 @@ module Fog
           hash['vm_size'] = vm.hardware_profile.vm_size
           hash['os_disk_name'] = vm.storage_profile.os_disk.name
           hash['os_disk_vhd_uri'] = vm.storage_profile.os_disk.vhd.uri
-          hash['publisher'] = vm.storage_profile.image_reference.publisher
-          hash['offer'] = vm.storage_profile.image_reference.offer
-          hash['sku'] = vm.storage_profile.image_reference.sku
-          hash['version'] = vm.storage_profile.image_reference.version
+          unless vm.storage_profile.image_reference.nil?
+            hash['publisher'] = vm.storage_profile.image_reference.publisher
+            hash['offer'] = vm.storage_profile.image_reference.offer
+            hash['sku'] = vm.storage_profile.image_reference.sku
+            hash['version'] = vm.storage_profile.image_reference.version
+          end
           hash['username'] = vm.os_profile.admin_username
           hash['custom_data'] = vm.os_profile.custom_data
           hash['data_disks'] = []
@@ -60,17 +63,19 @@ module Fog
           end
           hash['network_interface_card_id'] = vm.network_profile.network_interfaces[0].id
           hash['availability_set_id'] = vm.availability_set.id unless vm.availability_set.nil?
+
           hash
         end
 
         def save
           requires :name, :location, :resource_group, :vm_size, :storage_account_name,
-                   :username, :password, :network_interface_card_id, :publisher, :offer, :sku, :version
+                   :username, :password, :network_interface_card_id
           requires :disable_password_authentication if platform.casecmp('linux').zero?
+          requires :publisher, :offer, :sku, :version if vhd_path.nil?
           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)
-          merge_attributes(Fog::Compute::AzureRM::Server.parse(vm))
+          merge_attributes(Server.parse(vm))
         end
 
         def destroy
@@ -111,12 +116,12 @@ module Fog
 
         def attach_data_disk(disk_name, disk_size, storage_account_name)
           vm = service.attach_data_disk_to_vm(resource_group, name, disk_name, disk_size, storage_account_name)
-          merge_attributes(Fog::Compute::AzureRM::Server.parse(vm))
+          merge_attributes(Server.parse(vm))
         end
 
         def detach_data_disk(disk_name)
           vm = service.detach_data_disk_from_vm(resource_group, name, disk_name)
-          merge_attributes(Fog::Compute::AzureRM::Server.parse(vm))
+          merge_attributes(Server.parse(vm))
         end
 
         private
@@ -142,7 +147,8 @@ module Fog
             platform: platform,
             provision_vm_agent: provision_vm_agent,
             enable_automatic_updates: enable_automatic_updates,
-            custom_data: custom_data
+            custom_data: custom_data,
+            vhd_path: vhd_path
           }
         end
       end