fog 1.25.0 → 1.26.0

data/lib/fog/opennebula/compute.rb

@@ -17,7 +17,7 @@ module Fog
       collection  :interfaces
       model       :group
       collection  :groups
-      
+
       request_path 'fog/opennebula/requests/compute'
       request :list_vms
       request :list_groups

data/lib/fog/openstack/examples/compute/block_device_mapping_v2.rb

@@ -0,0 +1,30 @@
+# OpenStack Compute (Nova) Example
+
+require 'fog'
+require 'fog/openstack'
+
+auth_url = "https://example.net/v2.0/tokens"
+username = 'admin@example.net'
+password = 'secret'
+tenant   = 'My Compute Tenant' # String
+
+compute_client ||= ::Fog::Compute.new(:provider           => :openstack,
+                                      :openstack_api_key  => password  ,
+                                      :openstack_username => username  ,
+                                      :openstack_auth_url => auth_url  ,
+                                      :openstack_tenant   => tenant)
+
+vm = compute_client.servers.create(:name => name,
+                                   :flavor_ref => flavor,
+                                   :block_device_mapping => [
+                                     {
+                                       :api_ver => "v2",
+                                       :device_name => "/dev/vda1",
+                                       :source_type => "volume",
+                                       :destination_type => "volume",
+                                       :delete_on_termination => false,
+                                       :uuid => cinder_uddi,
+                                       :boot_index => 0
+                                     }
+                                   ]
+                                   )

data/lib/fog/openstack/identity.rb

@@ -8,7 +8,7 @@ module Fog
                  :openstack_service_type, :openstack_service_name, :openstack_tenant,
                  :openstack_api_key, :openstack_username, :openstack_current_user_id,
                  :current_user, :current_tenant,
-                 :openstack_endpoint_type
+                 :openstack_endpoint_type, :openstack_region
 
       model_path 'fog/openstack/models/identity'
       model       :tenant
@@ -174,6 +174,7 @@ module Fog
             missing_credentials = Array.new
             @openstack_api_key  = options[:openstack_api_key]
             @openstack_username = options[:openstack_username]
+            @openstack_region   = options[:openstack_region]
 
             missing_credentials << :openstack_api_key  unless @openstack_api_key
             missing_credentials << :openstack_username unless @openstack_username
@@ -260,7 +261,8 @@ module Fog
               :openstack_tenant   => @openstack_tenant,
               :openstack_service_type => @openstack_service_type,
               :openstack_service_name => @openstack_service_name,
-              :openstack_endpoint_type => @openstack_endpoint_type
+              :openstack_endpoint_type => @openstack_endpoint_type,
+              :openstack_region => @openstack_region
             }
 
             credentials = Fog::OpenStack.authenticate_v2(options, @connection_options)

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

@@ -50,7 +50,7 @@ module Fog
 
         attr_reader :password
         attr_writer :image_ref, :flavor_ref, :nics, :os_scheduler_hints
-        attr_accessor :block_device_mapping
+        attr_accessor :block_device_mapping, :block_device_mapping_v2
 
         def initialize(attributes={})
           # Old 'connection' is renamed as service and should be used instead
@@ -62,6 +62,7 @@ module Fog
           self.nics = attributes.delete(:nics)
           self.os_scheduler_hints = attributes.delete(:os_scheduler_hints)
           self.block_device_mapping = attributes.delete(:block_device_mapping)
+          self.block_device_mapping_v2 = attributes.delete(:block_device_mapping_v2)
 
           super
         end
@@ -326,7 +327,7 @@ module Fog
         def save
           raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
           requires :flavor_ref, :name
-          requires_one :image_ref, :block_device_mapping
+          requires_one :image_ref, :block_device_mapping, :block_device_mapping_v2
           options = {
             'personality' => personality,
             'accessIPv4' => accessIPv4,
@@ -340,7 +341,8 @@ module Fog
             'max_count'   => @max_count,
             'nics' => @nics,
             'os:scheduler_hints' => @os_scheduler_hints,
-            'block_device_mapping' => @block_device_mapping
+            'block_device_mapping' => @block_device_mapping,
+            'block_device_mapping_v2' => @block_device_mapping_v2,
           }
           options['metadata'] = metadata.to_hash unless @metadata.nil?
           options = options.reject {|key, value| value.nil?}

data/lib/fog/openstack/models/image/images.rb

@@ -11,8 +11,8 @@ module Fog
           load(service.list_public_images_detailed.body['images'])
         end
 
-        def details
-          load(service.list_public_images_detailed.body['images'])
+        def details(attribute=nil, query=nil)
+          load(service.list_public_images_detailed(attribute, query).body['images'])
         end
 
         def find_by_id(id)

data/lib/fog/openstack/models/network/floating_ips.rb

@@ -20,7 +20,7 @@ module Fog
         end
 
         def get(floating_network_id)
-          if floating_ip = connection.get_floating_ip(floating_network_id).body['floatingip']
+          if floating_ip = service.get_floating_ip(floating_network_id).body['floatingip']
             new(floating_ip)
           end
         rescue Fog::Network::OpenStack::NotFound

data/lib/fog/openstack/requests/compute/create_server.rb

@@ -57,23 +57,29 @@ module Fog
             data['os:scheduler_hints'] = options['os:scheduler_hints']
           end
 
-          if options['block_device_mapping']
-            data['server']['block_device_mapping'] =
-            [options['block_device_mapping']].flatten.map do |mapping|
+          if (block_device_mapping = options['block_device_mapping_v2'])
+            data['server']['block_device_mapping_v2'] = [block_device_mapping].flatten.collect do |mapping|
               {
-                'volume_size' => mapping[:volume_size],
-                'volume_id' => mapping[:volume_id],
+                'boot_index'            => mapping[:boot_index],
                 'delete_on_termination' => mapping[:delete_on_termination],
-                'device_name' => mapping[:device_name]
+                'destination_type'      => mapping[:destination_type],
+                'device_name'           => mapping[:device_name],
+                'source_type'           => mapping[:source_type],
+                'uuid'                  => mapping[:uuid],
+              }
+            end
+          elsif (block_device_mapping = options['block_device_mapping'])
+            data['server']['block_device_mapping'] = [block_device_mapping].flatten.collect do |mapping|
+              {
+                'delete_on_termination' => mapping[:delete_on_termination],
+                'device_name'           => mapping[:device_name],
+                'volume_id'             => mapping[:volume_id],
+                'volume_size'           => mapping[:volume_size],
               }
             end
           end
 
-          path = if data['server']['block_device_mapping']
-                   'os-volumes_boot.json'
-                 else
-                   'servers.json'
-                 end
+          path = block_device_mapping ? 'os-volumes_boot.json' : 'servers.json'
 
           request(
             :body     => Fog::JSON.encode(data),
@@ -142,6 +148,12 @@ module Fog
             }
           end
 
+          if block_devices = options["block_device_mapping_v2"]
+            block_devices.each { |bd| compute.volumes.get(bd[:uuid]).attach(server_id, bd[:device_name]) }
+          elsif block_device = options["block_device_mapping"]
+            compute.volumes.get(block_device[:volume_id]).attach(server_id, block_device[:device_name])
+          end
+
           self.data[:last_modified][:servers][server_id] = Time.now
           self.data[:servers][server_id] = mock_data
           if security_groups = options['security_groups'] then

data/lib/fog/openstack/requests/image/list_public_images_detailed.rb

@@ -3,16 +3,18 @@ module Fog
     class OpenStack
       class Real
         def list_public_images_detailed(attribute=nil, query=nil)
+          path = 'images/detail'
           if attribute
-            path = "images/detail?#{attribute}=#{URI::encode(query)}"
+            query = { attribute => URI::encode(query) }
           else
-            path = 'images/detail'
+            query = {}
           end
 
           request(
             :expects => [200, 204],
             :method  => 'GET',
-            :path    => path
+            :path    => path,
+            :query   => query
           )
         end
       end # class Real
@@ -23,8 +25,8 @@ module Fog
           response.status = [200, 204][rand(1)]
           response.body = {'images' => self.data[:images].values}
           response
-        end # def list_tenants
+        end # def list_public_images_detailed
       end # class Mock
     end # class OpenStack
-  end # module Identity
+  end # module Image
 end # module Fog

data/lib/fog/openstack/requests/storage/head_containers.rb

@@ -11,7 +11,7 @@ module Fog
         #     * 'X-Account-Bytes-Used'<~String> - Bytes used
         def head_containers
           request(
-            :expects  => 204,
+            :expects  => 200..299,
             :method   => 'HEAD',
             :path     => '',
             :query    => {'format' => 'json'}

data/lib/fog/rackspace.rb

@@ -11,3 +11,4 @@ require 'fog/rackspace/monitoring'
 require 'fog/rackspace/queues'
 require 'fog/rackspace/storage'
 require 'fog/rackspace/networking'
+require 'fog/rackspace/orchestration'

data/lib/fog/rackspace/core.rb

@@ -98,6 +98,7 @@ module Fog
     service(:monitoring,       'Monitoring')
     service(:queues,           'Queues')
     service(:networking,       'Networking')
+    service(:orchestration,    'Orchestration')
 
     def self.authenticate(options, connection_options = {})
       rackspace_auth_url = options[:rackspace_auth_url]

data/lib/fog/rackspace/docs/orchestration.md

@@ -0,0 +1,356 @@
+# OpenStack Orchestration
+The mission of the OpenStack Orchestration program is to create a human- and machine-accessible service for managing the entire lifecycle of infrastructure and applications within OpenStack clouds.
+
+## Heat
+Heat is the main project in the OpenStack Orchestration program. It implements an orchestration engine to launch multiple composite cloud applications based on templates in the form of text files that can be treated like code. A native Heat template format is evolving, but Heat also endeavours to provide compatibility with the AWS CloudFormation template format, so that many existing CloudFormation templates can be launched on OpenStack. Heat provides both an OpenStack-native ReST API and a CloudFormation-compatible Query API.
+
+*Why ‘Heat’? It makes the clouds rise!*
+
+**How it works**
+
+* A Heat template describes the infrastructure for a cloud application in a text file that is readable and writable by humans, and can be checked into version control, diffed, &c.
+* Infrastructure resources that can be described include: servers, floating ips, volumes, security groups, users, etc.
+* Heat also provides an autoscaling service that integrates with Ceilometer, so you can include a scaling group as a resource in a template.
+* Templates can also specify the relationships between resources (e.g. this volume is connected to this server). This enables Heat to call out to the OpenStack APIs to create all of your infrastructure in the correct order to completely launch your application.
+* Heat manages the whole lifecycle of the application - when you need to change your infrastructure, simply modify the template and use it to update your existing stack. Heat knows how to make the necessary changes. It will delete all of the resources when you are finished with the application, too.
+* Heat primarily manages infrastructure, but the templates integrate well with software configuration management tools such as Puppet and Chef. The Heat team is working on providing even better integration between infrastructure and software.
+
+_Source: [OpenStack Wiki](https://wiki.openstack.org/wiki/Heat)_
+
+# Rackspace Orchestration (Heat) Client
+
+[Full Rackspace Orchestration/Heat API Docs](http://docs.rackspace.com/orchestration/api/v1/orchestration-devguide/content/API_Operations_dle7023.html)
+
+## Orchestration Service
+Get a handle on the Orchestration service:
+
+```ruby
+irb: service = Fog::Rackspace::Orchestration.new({
+	:rackspace_username => username,
+	:rackspace_api_key  => api_key,
+  	:rackspace_region   => :iad #:ord, :dfw, :syd
+})
+===> #<Fog::Rackspace::Orchestration::Real:2168274880 ...
+```
+We will use this `service` to interact with the Orchestration resources, `stack`, `event`,  `resource`, and `template`
+
+## Stacks
+
+Get a list of stacks you own:
+
+```ruby
+irb: service.stacks
+===>   <Fog::Rackspace::Orchestration::Stacks
+    []
+  >
+```
+
+Create a new `stack` with a [Heat Template (HOT)](http://docs.openstack.org/developer/heat/template_guide/hot_guide.html). Here we are using Rackspace's HOT for [a single redis server]("https://github.com/rackspace-orchestration-templates/redis-single/blob/master/redis-single.yaml"):
+
+```ruby
+redis_template = File.read("spec/support/redis_template.yml")
+===> "heat_template_version: 2013-05-23\n\ndescription: ....
+
+irb:  service.stacks.new.save({
+		:stack_name => "a_redis_stack",
+		:template   => redis_template
+	})
+```
+
+We get back a JSON blob filled with info about our new stack:
+
+```ruby
+===> {"id"=>"73e0f38a-a9fb-4a4e-8196-2b63039ef31f", "links"=>[{"href"=>"https://iad.orchestration.api.rackspacecloud.com/v1/930035/stacks/a_redis_stack/73e0f38a-a9fb-4a4e-8196-2b63039ef31f", "rel"=>"self"}]}
+```
+
+Now that we have the `id` of our new stack, we can get a reference to it using the stack's `name` and `id`:
+
+
+```ruby
+irb: stack = service.stacks.get("a_redis_stack", "73e0f38a-a9fb-4a4e-8196-2b63039ef31f")
+===>   <Fog::Rackspace::Orchestration::Stack
+    id="73e0f38a-a9fb-4a4e-8196-2b63039ef31f",
+    description="This is a Heat template to deploy a standalone redis server on\nRackspace Cloud Servers\n",
+    links=[{"href"=>"https://iad.orchestration.api.rackspacecloud.com/v1/930035/stacks/a_redis_stack/73e0f38a-a9fb-4a4e-8196-2b63039ef31f", "rel"=>"self"}],
+    stack_status_reason="Stack CREATE started",
+    stack_name="a_redis_stack",
+    creation_time="2014-11-13T16:21:02Z",
+    updated_time=nil
+  >
+```
+A stack knows about related `events`:
+
+```ruby
+irb: stack.events
+===>   <Fog::Rackspace::Orchestration::Events
+    [
+      <Fog::Rackspace::Orchestration::Event
+        id="7b1830a3-5d7b-43b2-bc1b-cffbb25c8b3e",
+        resource_name="redis_server_config",
+        event_time="2014-11-13T16:21:45Z",
+        links=[{"href"=>"https://iad.orchestration.api.rackspacecloud.com/v1/930035/stacks/a_redis_stack/73e0f38a-a9fb-4a4e-8196-2b63039ef31f/resources/redis_server_config/events/7b1830a3-5d7b-43b2-bc1b-cffbb25c8b3e", "rel"=>"self"}, {"href"=>"https://iad.orchestration.api.rackspacecloud.com/v1/930035/stacks/a_redis_stack/73e0f38a-a9fb-4a4e-8196-2b63039ef31f/resources/redis_server_config", "rel"=>"resource"}, {"href"=>"https://iad.orchestration.api.rackspacecloud.com/v1/930035/stacks/a_redis_stack/73e0f38a-a9fb-4a4e-8196-2b63039ef31f", "rel"=>"stack"}],
+        logical_resource_id="redis_server_config",
+        resource_status="CREATE_IN_PROGRESS",
+        resource_status_reason="state changed",
+        physical_resource_id=nil
+      >,
+```
+A stack knows about related `resources`:
+
+```ruby
+irb: stack.resources
+===>   <Fog::Rackspace::Orchestration::Resources
+    [
+      <Fog::Rackspace::Orchestration::Resource
+        id=nil,
+        resource_name="redis_server",
+        description=nil,
+        links=[{"href"=>"https://iad.orchestration.api.rackspacecloud.com/v1/930035/stacks/a_redis_stack/73e0f38a-a9fb-4a4e-8196-2b63039ef31f/resources/redis_server", "rel"=>"self"}, {"href"=>"https://iad.orchestration.api.rackspacecloud.com/v1/930035/stacks/a_redis_stack/73e0f38a-a9fb-4a4e-8196-2b63039ef31f", "rel"=>"stack"}],
+        logical_resource_id="redis_server",
+        resource_status="CREATE_COMPLETE",
+        updated_time="2014-11-13T16:21:04Z",
+        required_by=["redis_server_config"],
+        resource_status_reason="state changed",
+        resource_type="Rackspace::Cloud::Server"
+      >,
+```
+
+You can list, limit, sort stacks based on certain keywords:
+
+** Available keywords:**
+
+* status
+* ​name
+* ​limit
+* ​marker
+* ​sort_keys
+* sort_dir
+
+```ruby
+irb:  stacks = service.stacks.all(sort_key: "stack_name", sort_dir: "asc")
+===>   <Fog::Rackspace::Orchestration::Stacks
+    [
+      <Fog::Rackspace::Orchestration::Stack
+        id="73e0f38a-a9fb-4a4e-8196-2b63039ef31f",
+        description="This is a Heat template to deploy a standalone redis server on\nRackspace Cloud Servers\n",
+        links=[{"href"=>"https://iad.orchestration.api.rackspacecloud.com/v1/930035/stacks/a_redis_stack/73e0f38a-a9fb-4a4e-8196-2b63039ef31f", "rel"=>"self"}],
+        stack_status_reason="Stack CREATE started",
+        stack_name="a_redis_stack",
+        creation_time="2014-11-13T16:21:02Z",
+        updated_time=nil
+      >
+    ]
+  >
+```
+You can get a stack's `template`
+
+```ruby
+irb: stack.template
+===>   <Fog::Rackspace::Orchestration::Template
+    description="This is a Heat template to deploy a standalone redis server on\nRackspace Cloud Servers\n",
+    heat_template_version="2013-05-23",
+    ....
+```
+You can abandon a stack -- essentially, it will delete the stack, but keep the resources around for potential further use:
+
+```ruby
+irb: stack.abandon
+===> #<Excon::Response:0x00000104d6b870 @data={:body=>{"status"=>"IN_PROGRESS", "name"=>"a_redis_stack", "stack_user_project_id"=>"930035", "environment"=>{"parameters"=>{}, "resource_registry"=>{"resources"=>{}}}, "template"=>{"parameter_groups"=>[{"parameters"=>["flavor", "image"], "label"=>"Server Settings"}, {"parameters"=>["redis_port"], "label"=>"Redis Settings"}, {"parameters"=>["redis_version", "redis_hostname", "kitchen", "chef_version"], "label"=>"rax-dev-params"}], "heat_template_version"=>"2013-05-23", "description"=>"This is a Heat te
+```
+
+You can preview a stack:
+
+```ruby
+irb: service.stacks.preview({
+		:stack_name => "a_redis_template",
+		:template   => redis_template
+	})
+===>   <Fog::Rackspace::Orchestration::Stack
+    id="None",
+    description="This is a Heat template to deploy a standalone redis server on\nRackspace Cloud Servers\n",
+    links=[{"href"=>"https://iad.orchestration.api.rackspacecloud.com/v1/930035/stacks/a_redis_template/None", "rel"=>"self"}],
+    stack_status_reason=nil,
+    stack_name="a_redis_template",
+    creation_time="2014-11-13T16:33:50Z",
+    updated_time=nil
+  >
+```
+
+Of course, you can just delete a stack. This deletes associated `resources` (as opposed to `abandon`):
+
+```ruby
+irb: stack.delete
+===> #<Excon::Response:0x0000010198b000 @data={:body=>"", :headers=>{"Server"=>"nginx/1.2.1", "Date"=>"Thu, 13 Nov 2014 16:28:38 GMT", "Content-Type"=>"text/html; charset=UTF-8", "Connection"=>"keep-alive", "Via"=>"1.0 Repose (Repose/6.0.2)"}, :status=>204, :reason_phrase=>"No Content", :remote_ip=>"23.253.147.138", :local_port=>54721, :local_address=>"192.168.1.65"}, @body="", @headers={"Server"=>"nginx/1.2.1", "Date"=>"Thu, 13 Nov 2014 16:28:38 GMT", "Content-Type"=>"text/html; charset=UTF-8", "Connection"=>"keep-alive", "Via"=>"1.0 Repose (Repose/6.0.2)"}, @status=204, @remote_ip="23.253.147.138", @local_port=54721, @local_address="192.168.1.65">
+```
+
+Reload any object by calling `reload` on it:
+
+```ruby
+irb: stacks.reload
+===>   <Fog::Rackspace::Orchestration::Stacks
+    []
+  >
+```
+You can get build information:
+
+```ruby
+irb: service.stacks.build_info
+===> {"engine"=>{"revision"=>"2014.k1-20141027-1178"}, "fusion-api"=>{"revision"=>"j1-20140915-10d9ee4-98"}, "api"=>{"revision"=>"2014.k1-20141027-1178"}}
+```
+
+## Events
+
+`Events` are indexable and can be scoped by `stack`:
+
+```ruby
+irb: event = stack.events.first
+===>   <Fog::Rackspace::Orchestration::Event
+    id="7b1830a3-5d7b-43b2-bc1b-cffbb25c8b3e",
+    resource_name="redis_server_config",
+    event_time="2014-11-13T16:21:45Z",
+    links=[{"href"=>"https://iad.orchestration.api.rackspacecloud.com/v1/930035/stacks/a_redis_stack/73e0f38a-a9fb-4a4e-8196-2b63039ef31f/resources/redis_server_config/events/7b1830a3-5d7b-43b2-bc1b-cffbb25c8b3e", "rel"=>"self"}, {"href"=>"https://iad.orchestration.api.rackspacecloud.com/v1/930035/stacks/a_redis_stack/73e0f38a-a9fb-4a4e-8196-2b63039ef31f/resources/redis_server_config", "rel"=>"resource"}, {"href"=>"https://iad.orchestration.api.rackspacecloud.com/v1/930035/stacks/a_redis_stack/73e0f38a-a9fb-4a4e-8196-2b63039ef31f", "rel"=>"stack"}],
+    logical_resource_id="redis_server_config",
+    resource_status="CREATE_IN_PROGRESS",
+    resource_status_reason="state changed",
+    physical_resource_id=nil
+  >
+```
+
+`Events` can be sorted, limited, etc by passing an hash like so:
+`service.events.all(stack, limit: 1)`
+
+** Available keys: **
+
+* resource_action
+* resource_status
+* resource_name
+* ​resource_type
+* ​limit
+* ​marker
+* sort_keys
+* ​sort_dir
+
+They are getable:
+
+```ruby
+irb: event = service.events.get(stack, resource, event_id)
+===>   <Fog::Rackspace::Orchestration::Event
+    id="7b1830a3-5d7b-43b2-bc1b-cffbb25c8b3e",
+    resource_name="redis_server_config",
+    event_time="2014-11-13T16:21:45Z",
+    links=[{"href"=>"https://iad.orchestration.api.rackspacecloud.com/v1/930035/stacks/a_redis_stack/73e0f38a-a9fb-4a4e-8196-2b63039ef31f/resources/redis_server_config/events/7b1830a3-5d7b-43b2-bc1b-cffbb25c8b3e", "rel"=>"self"}, {"href"=>"https://iad.orchestration.api.rackspacecloud.com/v1/930035/stacks/a_redis_stack/73e0f38a-a9fb-4a4e-8196-2b63039ef31f/resources/redis_server_config", "rel"=>"resource"}, {"href"=>"https://iad.orchestration.api.rackspacecloud.com/v1/930035/stacks/a_redis_stack/73e0f38a-a9fb-4a4e-8196-2b63039ef31f", "rel"=>"stack"}],
+    logical_resource_id="redis_server_config",
+    resource_status="CREATE_IN_PROGRESS",
+    resource_status_reason="state changed",
+    physical_resource_id=nil
+  >
+```
+
+An `event` knows about its associated `stack`:
+
+```ruby
+irb: event.stack
+===>   <Fog::Rackspace::Orchestration::Stack
+    id="73e0f38a-a9fb-4a4e-8196-2b63039ef31f",
+    description="This is a Heat template to deploy a standalone redis server on\nRackspace Cloud Servers\n",
+    links=[{"href"=>"https://iad.orchestration.api.rackspacecloud.com/v1/930035/stacks/a_redis_stack/73e0f38a-a9fb-4a4e-8196-2b63039ef31f", "rel"=>"self"}],
+    stack_status_reason="Stack CREATE completed successfully",
+    stack_name="a_redis_stack",
+    creation_time="2014-11-13T16:21:02Z",
+    updated_time=nil
+  >
+```
+
+You can list, limit, sort events based on certain keywords:
+
+```ruby
+irb: events = stack.events.all(stack, sort_key: "resource_name", sort_dir: "desc", limit: 3)
+===>   <Fog::Rackspace::Orchestration::Events
+    [
+      <Fog::Rackspace::Orchestration::Event
+        id="9cdae7d7-f44e-4dbb-bc0b-61ea6da9cf81",
+        resource_name="redis_server_config",
+        event_time="2014-11-13T16:24:07Z",
+        ....
+```
+
+An  `event` has an associated `resource`:
+
+```ruby
+irb: resource = event.resource
+===>   <Fog::Rackspace::Orchestration::Resource
+    id=nil,
+    resource_name="redis_server_config",
+    description="",
+    links=[{"href"=>"https://iad.orchestration.api.rackspacecloud.com/v1/930035/stacks/a_redis_stack/73e0f38a-a9fb-4a4e-8196-2b63039ef31f/resources/redis_server_config", "rel"=>"self"}, {"href"=>"https://iad.orchestration.api.rackspacecloud.com/v1/930035/stacks/a_redis_stack/73e0f38a-a9fb-4a4e-8196-2b63039ef31f", "rel"=>"stack"}],
+    logical_resource_id="redis_server_config",
+    resource_status="CREATE_COMPLETE",
+    updated_time="2014-11-13T16:21:45Z",
+    required_by=[],
+    resource_status_reason="state changed",
+    resource_type="OS::Heat::ChefSolo"
+  >
+```
+
+## Resource
+
+`resources` are indexable:
+
+```ruby
+irb: service.resources.all(stack, {nested_depth: 1})
+===>   <Fog::Rackspace::Orchestration::Resources
+    [
+      <Fog::Rackspace::Orchestration::Resource
+        id=nil,
+        resource_name="redis_server",
+        description=nil,
+        links=[{"href"=>"https://iad.orchestration.api.rackspacecloud.com/v1/930035/stacks/a_redis_stack/ee648a3b-14a3-4df8-aa58-620a9d67e3e5/resources/redis_server", "rel"=>"self"}, {"href"=>"https://iad.orchestration.api.rackspacecloud.com/v1/930035/stacks/a_redis_stack/ee648a3b-14a3-4df8-aa58-620a9d67e3e5", "rel"=>"stack"}],
+        logical_resource_id="redis_server",
+        resource_status="CREATE_COMPLETE",
+        updated_time="2014-11-13T16:32:30Z",
+        required_by=["redis_server_config"],
+        resource_status_reason="state changed",
+        resource_type="Rackspace::Cloud::Server"
+      >,
+      ...
+```
+
+A `resource` knows about its associated `stack`:
+
+```ruby
+irb: resource.stack
+===>   <Fog::Rackspace::Orchestration::Stack
+    id="73e0f38a-a9fb-4a4e-8196-2b63039ef31f",
+    description="This is a Heat template to deploy a standalone redis server on\nRackspace Cloud Servers\n",
+    links=[{"href"=>"https://iad.orchestration.api.rackspacecloud.com/v1/930035/stacks/a_redis_stack/73e0f38a-a9fb-4a4e-8196-2b63039ef31f", "rel"=>"self"}],
+    stack_status_reason="Stack CREATE completed successfully",
+    stack_name="a_redis_stack",
+    creation_time="2014-11-13T16:21:02Z",
+    updated_time=nil
+  >
+```
+
+Resource metadata is visible:
+
+```ruby
+irb: resource.metadata
+===> {}
+```
+
+A `resource's` template is visible (if one exists)
+
+```ruby
+irb: resource.template
+===> nil
+```
+
+## Validation
+You can validate a Heat template (HOT) before using it:
+
+```ruby
+irb: service.templates.validate({:template => redis_template})
+===>   <Fog::Rackspace::Orchestration::Template
+    description="This is a Heat template to deploy a standalone redis server on\nRackspace Cloud Servers\n",
+    heat_template_version=nil,
+    ...
+```