fog-azure-rm 0.0.3 → 0.0.4

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

@@ -0,0 +1,155 @@
+#Resources
+
+This document explains how to get started using Azure Resources Service with Fog. With this gem you can create/update/list/delete resource groups.
+
+## Usage
+
+First of all, you need to require the Fog library by executing:
+
+```ruby
+require 'fog/azurerm'
+```
+
+## Create Connection
+
+Next, create a connection to the Resources Service:
+
+```ruby
+    azure_resources_service = Fog::Resources::AzureRM.new(
+        tenant_id:       '<Tenantid>',           # Tenant id of Azure Active Directory Application
+        client_id:       '<Clientid>',           # Client id of Azure Active Directory Application
+        client_secret:   '<ClientSecret>',       # Client Secret of Azure Active Directory Application
+        subscription_id: '<Subscriptionid>'      # Subscription id of an Azure Account
+)
+```
+## Create Resource Group
+
+Create a new resource group
+
+```ruby
+    azure_resources_service.resource_groups.create(
+        name:     '<Resource Group name>',
+        location: 'West US'
+ )
+```
+## List Resource Groups
+
+```ruby
+    azure_resources_service.resource_groups.each do |resource_group|
+        puts "#{resource_group.name}"
+        puts "#{resource_group.location}"
+    end
+```
+
+## Retrieve a single Resource Group
+
+Get a single record of Resource Group
+
+```ruby
+      resource_group = azure_resources_service
+                          .resource_groups
+                          .get('<Resource Group name>')
+      puts "#{resource_group.name}"
+```
+
+## Destroy a single Resource Group
+
+Get resource group object from the get method(described above) and then destroy that resource group.
+
+```ruby
+      resource_group.destroy
+```
+## Tagging a Resource
+
+You can tag a Resource as following:
+
+```ruby
+    azure_resources_service.tag_resource(
+        '<Resource-ID>',
+        '<Tag-Key>',
+        '<Tag-Value>'
+    )
+```
+
+## List Tagged Resources in a Subscription
+
+```ruby
+    azure_resources_service.resources(tag_name: '<Tag-Key>', tag_value: '<Tag-Value>').each do |resource|
+        puts "#{resource.name}"
+        puts "#{resource.location}"
+        puts "#{resource.type}"        
+    end
+```
+OR
+```ruby
+    azure_resources_service.resources(tag_name: '<Tag-Key>').each do |resource|
+        puts "#{resource.name}"
+        puts "#{resource.location}"
+        puts "#{resource.type}"        
+    end
+```
+## Retrieve a single Resource
+
+Get a single record of Tagged Resources
+
+```ruby
+    resource = azure_resources_service
+                          .resources(tag_name: '<Tag-Key>')
+                          .get('<Resource-ID>')
+    puts "#{resource.name}"
+```
+## Remove tag from a Resource
+
+Remove tag from a resource as following:
+
+```ruby
+    azure_resources_service.delete_resource_tag(
+        '<Resource-ID>',
+        '<Tag-Key>',
+        '<Tag-Value>'
+        )
+```
+
+## Create Deployment
+
+Create a Deployment
+
+```ruby
+    azure_resources_service.deployments.create(
+        name:            '<Deployment name>',
+        resource_group:  '<Resource Group name>',
+        template_link:   '<Template Link>',
+        parameters_link: '<Parameters Link>'
+ )
+```
+## List Deployments
+
+List Deployments in a resource group
+
+```ruby
+    azure_resources_service.deployments(resource_group: '<Resource Group Name>').each do |deployment|
+        puts "#{deployment.name}"
+    end
+```
+
+## Retrieve a single Deployment
+
+Get a single record of Deployment
+
+```ruby
+      deployment = azure_resources_service
+                          .deployments(resource_group: '<Resource Group name>')
+                          .get('<Deployment name>')
+      puts "#{deployment.name}"
+```
+
+## Destroy a single Deployment
+
+Get Deployment object from the get method(described above) and then destroy that Deployment.
+
+```ruby
+      deployment.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/storage.md

@@ -0,0 +1,222 @@
+#Storage
+
+This document explains how to get started using Azure Storage Service with Fog. With this gem you can create/update/list/delete storage accounts.
+
+## Usage
+
+First of all, you need to require the Fog library by executing:
+
+```ruby
+require 'fog/azurerm'
+```
+
+## Create Connection
+
+Next, create a connection to the Storage Service:
+
+```ruby
+azure_storage_service = Fog::Storage.new(
+  :provider => 'AzureRM',
+  :tenant_id => '<Tenantid>',                                     # Tenant id of Azure Active Directory Application
+  :client_id =>    '<Clientid>',                                  # Client id of Azure Active Directory Application
+  :client_secret => '<ClientSecret>',                             # Client Secret of Azure Active Directory Application
+  :subscription_id => '<Subscriptionid>'                          # Subscription id of an Azure Account
+  :azure_storage_account_name => '<StorageAccountName>'           # Name of an Azure Storage Account
+  :azure_storage_access_key => '<StorageAccountKey>'              # Key of an Azure Storage Account
+  :azure_storage_connection_string => '<StorageConnectionString>' # Connection String of an Azure Storage Account
+)
+```
+
+If you only want to manage the storage accounts, you can create the connection without the storage account information:
+
+```ruby
+azure_storage_service = Fog::Storage.new(
+  :provider => 'AzureRM',
+  :tenant_id => '<Tenantid>',                                     # Tenant id of Azure Active Directory Application
+  :client_id =>    '<Clientid>',                                  # Client id of Azure Active Directory Application
+  :client_secret => '<ClientSecret>',                             # Client Secret of Azure Active Directory Application
+  :subscription_id => '<Subscriptionid>'                          # Subscription id of an Azure Account
+)
+```
+
+If you only want to manage the storage data, you can create the connection without the Azure subscription information:
+
+```ruby
+azure_storage_service = Fog::Storage.new(
+  :provider => 'AzureRM',
+  :azure_storage_account_name => '<StorageAccountName>'           # Name of an Azure Storage Account
+  :azure_storage_access_key => '<StorageAccountKey>'              # Key of an Azure Storage Account
+  :azure_storage_connection_string => '<StorageConnectionString>' # Connection String of an Azure Storage Account (optional)
+)
+```
+
+## Check Name Availability 
+
+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>')
+```
+
+## Create Storage Account
+
+Create a new storage account
+
+```ruby
+azure_storage_service.storage_accounts.create(
+  :name => '<Storage Account name>',
+  :location => 'West US',
+  :resource_group => '<Resource Group name>'
+)
+```
+## List storage accounts
+
+##### List storage accounts in a subscription
+
+```ruby
+azure_storage_service.storage_accounts.each do |storage_acc|
+  puts "#{storage_acc.name}"
+  puts "#{storage_acc.location}"
+end
+```
+##### List storage accounts in a resource group
+
+```ruby
+storage_accounts  = azure_storage_service.storage_accounts(resource_group: '<Resource Group name>')
+storage_accounts.each do |storage_acc|
+  puts "#{storage_acc.name}"
+  puts "#{storage_acc.location}"
+end
+```
+
+## Retrieve a single Storage Account
+
+Get a single record of Storage Account
+
+```ruby
+storage_acc = azure_storage_service
+                .storage_accounts(resource_group: '<Resource Group name>')
+                .get('<Storage Account name>')
+puts "#{storage_acc.name}"
+```
+
+## Get Access Keys
+
+Get access keys of a storage account
+
+```ruby
+keys_hash = storage_acc.get_access_keys
+puts "#{keys_hash['key1']} #{keys_hash['key2']}"
+```
+
+## Destroy a single Storage Account
+
+Get storage account object from the get method and then destroy that storage account.
+
+```ruby
+storage_acc.destroy
+```
+
+## Delete a Disk
+
+Delete a Disk from a storage account. Disk must be in unlocked state i.e detached from server(virtual machine) to successfully perform this action.
+
+```ruby
+azure_storage_service.delete_disk('<Resource Group name>', '<Storage Account name>', '<Data Disk Name>')
+```
+
+## Create a storage container
+
+Create a storage container in the current storage account.
+
+```ruby
+container = azure_storage_service.create_container(
+  name: '<container name>'
+)
+puts "#{container.name}"
+```
+
+## List storage containers
+
+List all the storage containers in the current storage accounts.
+
+```ruby
+azure_storage_service.containers.each do |container|
+  puts "#{container.name}"
+end
+```
+
+## 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
+puts "#{properties.inspect}"
+```
+
+## 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
+container = azure_storage_service.containers.get('<container name>')
+access_control_list = container.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
+container = azure_storage_service.containers.get('<container name>')
+result = container.destroy
+puts "#{result}"
+```
+
+### 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
+
+```ruby
+      azure_storage_service.blobs.get_blob_metadata('<Container name>', '<Blob name>')
+```
+
+## Set Blob Metadata
+
+```ruby
+      metadata = {
+        "Category" => "Images",
+        "Resolution" => "High"
+      }
+      azure_storage_service.blobs.set_blob_metadata('<Container name>', '<Blob name>', metadata)
+```
+
+## Get Container Metadata
+
+```ruby
+      azure_storage_service.containers.get_container_metadata('<Container name>')
+```
+
+## Set Container Metadata
+
+```ruby
+      metadata = {
+        "CreatedBy" => "User",
+        "SourceMachine" => "Mymachine",
+        "category" => "guidance",
+        "docType" => "textDocuments"
+       }
+      azure_storage_service.containers.set_container_metadata('<Container name>', metadata)
+```
+
+## 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/structure.md

@@ -0,0 +1,53 @@
+# Fog
+Whether you need compute, dns, storage, or a multitude of other services, fog provides an accessible entry point and facilitates cross service compatibility. Fog delivers the knowledge of cloud experts to you, helping you to bootstrap your cloud usage and guiding you as your own expertise develops.
+ 
+By coding with fog from the start you avoid vendor lock-in and give yourself more flexibility to provide value. Whether you are writing a library, designing a software as a service product or just hacking on the weekend this flexibility is a huge boon.
+
+# Structure
+fog is the Ruby cloud computing library, top to bottom:
+
+- Collections provide a simplified interface, making clouds easier to work with and switch between.
+- Requests allow power users to get the most out of the features of each individual cloud.
+- Mocks make testing and integrating a breeze.
+
+#### Collections
+Some collections are available across multiple providers:
+- dns providers have `zones` and `records`
+- compute providers have `images` and `servers`
+
+Collections share basic CRUD type operations, such as: 
+- **all** - fetch every object of that type from the provider.
+- **get** - fetch a single object by it’s identity from the provider.
+
+#### Models
+Many of the collection methods return individual objects, which also provide common methods:
+- **destroy** - will destroy the persisted object from the provider.
+- **save** - persist the object to the provider.
+
+#### Requests
+Requests allow you to dive deeper when the models just can’t cut it. You can see a list of available requests by calling `requests` on the connection object.
+
+#### Mocks
+As you might imagine, testing code using fog can be slow and expensive, constantly turning on and shutting down instances. Mocking allows skipping this overhead by providing an in-memory representation resources as you make requests.
+
+# Fog Provider Directory Structure
+```sh
+Plugin Root
+      |--- lib
+            |--- fog
+                 |--- azurerm.rb #registers provider
+                 |--- azurerm
+                       |--- compute.rb #registers all models, collections and requests
+                       |--- dns.rb #registers all models, collections and requests
+                       |--- storage.rb #registers all models, collections and requests
+                       |--- models #models and collections
+                       	     |--- compute #models and collections for compute
+                             |--- dns
+                             |--- storage
+                       |--- requests #requests - includes Real and Mock Classes
+                       	     |--- compute #requests for compute
+                             |--- dns
+                             |--- storage
+```
+
+For more information aboute fog struture [Click Here](http://fog.io/about/structure.html)

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

@@ -1,3 +1,4 @@
+require 'fog/azurerm/models/storage/data_disk'
 module Fog
   module Compute
     class AzureRM
@@ -45,8 +46,8 @@ module Fog
           hash['data_disks'] = []
 
           vm['properties']['storageProfile']['dataDisks'].each do |disk|
-            data_disk = Fog::Compute::AzureRM::DataDisk.new
-            hash['data_disks'] << data_disk.merge_attributes(Fog::Compute::AzureRM::DataDisk.parse(disk))
+            data_disk = Fog::Storage::AzureRM::DataDisk.new
+            hash['data_disks'] << data_disk.merge_attributes(Fog::Storage::AzureRM::DataDisk.parse(disk))
           end unless vm['properties']['storageProfile']['dataDisks'].nil?
 
           hash['disable_password_authentication'] =

data/lib/fog/azurerm/models/network/frontend_ip_configuration.rb

@@ -16,10 +16,14 @@ module Fog
           hash['name'] = frontend_ip_configuration['name']
           subnet = frontend_ip_configuration['properties']['subnet']
           hash['subnet_id'] = subnet['id'] unless subnet.nil?
-          private_ip_address = frontend_ip_configuration['properties']['privateIPAllocationMethod']
+          private_ip_address = frontend_ip_configuration['properties']['private_ipaddress']
           unless private_ip_address.nil?
             hash['private_ipaddress'] = private_ip_address
           end
+          private_ipallocation_method = frontend_ip_configuration['properties']['privateIPAllocationMethod']
+          unless private_ipallocation_method.nil?
+            hash['private_ipallocation_method'] = private_ipallocation_method
+          end
           public_ip_address = frontend_ip_configuration['properties']['publicIPAddress']
           unless public_ip_address.nil?
             hash['public_ip_address_id'] = public_ip_address['id']