fog 1.15.0 → 1.16.0

data/lib/fog/rackspace/examples/compute_v2/bootstrap_server.rb

@@ -0,0 +1,98 @@
+#!/usr/bin/env ruby
+
+# This example demonstrates creating a server with the Rackpace Open Cloud
+
+require 'rubygems' #required for Ruby 1.8.x
+require 'fog'
+require 'base64' #required to encode files for personality functionality
+require 'sshkey' #required to generate ssh keys. 'gem install sshkey'
+
+def get_user_input(prompt)
+  print "#{prompt}: "
+  gets.chomp
+end
+
+# Use username defined in ~/.fog file, if absent prompt for username. 
+# For more details on ~/.fog refer to http://fog.io/about/getting_started.html
+def rackspace_username
+  Fog.credentials[:rackspace_username] || get_user_input("Enter Rackspace Username")
+end
+
+# Use api key defined in ~/.fog file, if absent prompt for api key
+# For more details on ~/.fog refer to http://fog.io/about/getting_started.html
+def rackspace_api_key
+  Fog.credentials[:rackspace_api_key] || get_user_input("Enter Rackspace API key")
+end
+
+# Generates a ssh key using the SSHKey library. The private key is avaialble via
+# the '.private_key' and the public key is avaialble via '.ssh_public_key'
+def generate_ssh_key
+  SSHKey.generate
+end
+
+# create Next Generation Cloud Server service
+service = Fog::Compute.new({
+  :provider             => 'rackspace',
+  :rackspace_username   => rackspace_username,
+  :rackspace_api_key    => rackspace_api_key,
+  :version => :v2,  # Use Next Gen Cloud Servers
+  :rackspace_region => :ord #Use Chicago Region
+})
+
+# pick the first flavor
+flavor = service.flavors.first
+
+# pick the first Ubuntu image we can find
+image = service.images.find {|image| image.name =~ /Ubuntu/}
+
+# prompt for server name
+server_name = get_user_input "\nEnter Server Name"
+
+# generate the ssh key
+ssh_key = generate_ssh_key
+
+# reload flavor in order to retrieve all of its attributes
+flavor.reload
+
+puts "\nNow creating server '#{server_name}' the following with specifications:\n" 
+puts "\t* #{flavor.ram} MB RAM"
+puts "\t* #{flavor.disk} GB"
+puts "\t* #{flavor.vcpus} CPU(s)"
+puts "\t* #{image.name}"
+puts "\n"
+
+begin
+  # bootstrap server
+  server = service.servers.bootstrap :name => server_name, 
+                                     :flavor_id => flavor.id, 
+                                     :image_id => image.id,
+                                     :private_key => ssh_key.private_key,
+                                     :public_key => ssh_key.ssh_public_key
+
+  if server.ready?
+    puts "[DONE]\n\n"
+
+    puts "The server has been successfully created.\n"
+    puts "Write the following ssh keys to you ~/.ssh directory in order to log in\n\n"
+    puts "+++++++++++PRIVATE_KEY (~/.ssh/fog_key)++++++++++++"
+    puts ssh_key.private_key
+    puts "++++++++++PUBLIC_KEY (~/.ssh/fog_key.pub)++++++++++"
+    puts ssh_key.ssh_public_key
+    puts "+++++++++++++++++++++++++++++++++++++++++++++++++++i\n\n"
+
+    puts "You can then log into the server using the following command\n"
+    puts "ssh #{server.username}@#{server.public_ip_address}\n\n"
+  else
+    puts "An error occured, please try again"
+  end
+  
+rescue Fog::Errors::TimeoutError
+  puts "[TIMEOUT]\n\n"
+  
+  puts "This server is currently #{server.progress}% into the build process and is taking longer to complete than expected."
+  puts "You can continute to monitor the build process through the web console at https://mycloud.rackspace.com/\n\n" 
+end
+
+puts "To delete the server please execute the delete_server.rb script\n\n"
+
+

data/lib/fog/rackspace/examples/compute_v2/create_network.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+
+# This example demonstrates creating a private network and attaching it to a new server with the Rackpace Open Cloud
+
+require 'rubygems' #required for Ruby 1.8.x
+require 'fog'
+
+# UUID for INTERNET
+INTERNET = '00000000-0000-0000-0000-000000000000'
+
+# UUID for Rackspace's service net
+SERVICE_NET = '11111111-1111-1111-1111-111111111111'
+
+def get_user_input(prompt)
+  print "#{prompt}: "
+  gets.chomp
+end
+
+# Use username defined in ~/.fog file, if absent prompt for username.
+# For more details on ~/.fog refer to http://fog.io/about/getting_started.html
+def rackspace_username
+  Fog.credentials[:rackspace_username] || get_user_input("Enter Rackspace Username")
+end
+
+# Use api key defined in ~/.fog file, if absent prompt for api key
+# For more details on ~/.fog refer to http://fog.io/about/getting_started.html
+def rackspace_api_key
+  Fog.credentials[:rackspace_api_key] || get_user_input("Enter Rackspace API key")
+end
+
+# create Next Generation Cloud Server service
+service = Fog::Compute.new({
+  :provider             => 'rackspace',
+  :rackspace_username   => rackspace_username,
+  :rackspace_api_key    => rackspace_api_key,
+  :version => :v2,  # Use Next Gen Cloud Servers
+  :rackspace_region => :ord #Use Chicago Region
+})
+
+#create private network called my_private_net with an ip range between 192.168.0.1 - 192.168.0.255 (Note this will accept IPv6 CIDRs as well)
+net = service.networks.create :label => 'my_private_net', :cidr => '192.168.0.0/24'
+
+puts "\nCreating #{net.label} Network with CIDR #{net.cidr}"
+
+# pick the first flavor
+flavor = service.flavors.first
+
+# pick the first Ubuntu image we can find
+image = service.images.find {|image| image.name =~ /Ubuntu/}
+
+# Create a server called alphabits connected our private network as well as the internet
+server = service.servers.create :name => 'alphabits',
+                                :flavor_id => flavor.id,
+                                :image_id => image.id,
+                                :networks => [net.id, INTERNET]
+
+puts "\nNow creating server '#{server.name}' connected the the Internet and '#{net.label}'\n"
+
+begin
+  # Check every 5 seconds to see if server is in the active state (ready?).
+  # If the server has not been built in 5 minutes (600 seconds) an exception will be raised.
+  server.wait_for(600, 5) do
+    print "."
+    STDOUT.flush
+    ready?
+  end
+
+  puts "[DONE]\n\n"
+
+  puts "The server has been successfully created, to login onto the server:\n\n"
+  puts "\t ssh #{server.username}@#{server.public_ip_address}\n\n"
+
+rescue Fog::Errors::TimeoutError
+  puts "[TIMEOUT]\n\n"
+
+  puts "This server is currently #{server.progress}% into the build process and is taking longer to complete than expected."
+  puts "You can continute to monitor the build process through the web console at https://mycloud.rackspace.com/\n\n"
+end
+
+puts "The #{server.username} password is #{server.password}\n\n"
+puts "To delete the server and private network please execute the delete_network.rb script\n\n"

data/lib/fog/rackspace/examples/compute_v2/delete_network.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+
+# This example demonstrates deletes a private network and attaching it to a new server with the Rackpace Open Cloud
+
+require 'rubygems' #required for Ruby 1.8.x
+require 'fog'
+
+def wait_for_server_deletion(server)
+  begin
+    server.wait_for { state = 'DELETED' }
+  rescue Fog::Compute::RackspaceV2::NotFound => e
+    # do nothing
+  end
+end
+
+# I have notice that cloud networks is slow to acknowledge deleted servers. This method tries to mitigate this.
+def delete_network(network)
+  attempt = 0
+  begin
+    network.destroy
+  rescue Fog::Compute::RackspaceV2::ServiceError => e
+    if attempt == 3
+       puts  "Unable to delete #{network.label}"
+      return false
+    end
+     puts "Network #{network.label} Delete Fail Attempt #{attempt}- #{e.inspect}"
+    attempt += 1
+    sleep 60
+    retry
+  end
+  return true
+end
+
+def get_user_input(prompt)
+  print "#{prompt}: "
+  gets.chomp
+end
+
+# Use username defined in ~/.fog file, if absent prompt for username.
+# For more details on ~/.fog refer to http://fog.io/about/getting_started.html
+def rackspace_username
+  Fog.credentials[:rackspace_username] || get_user_input("Enter Rackspace Username")
+end
+
+# Use api key defined in ~/.fog file, if absent prompt for api key
+# For more details on ~/.fog refer to http://fog.io/about/getting_started.html
+def rackspace_api_key
+  Fog.credentials[:rackspace_api_key] || get_user_input("Enter Rackspace API key")
+end
+
+# create Next Generation Cloud Server service
+service = Fog::Compute.new({
+  :provider             => 'rackspace',
+  :rackspace_username   => rackspace_username,
+  :rackspace_api_key    => rackspace_api_key,
+  :version => :v2,  # Use Next Gen Cloud Servers
+  :rackspace_region => :ord #Use Chicago Region
+})
+
+# NOTE: The network must not be connected to any servers before deletion
+
+# Find alpha bits server
+server = service.servers.find {|s| s.name == 'alphabits'}
+
+puts "\n"
+if server
+  puts "Deleting alphabits server..."
+  server.destroy
+else
+  puts "Unable to find server alphabits"
+end
+
+wait_for_server_deletion(server)
+
+network = service.networks.find {|n| n.label == 'my_private_net'}
+delete_network(network)
+
+puts "The network '#{network.label}' has been successfully deleted"

data/lib/fog/rackspace/load_balancers.rb

@@ -73,6 +73,7 @@ module Fog
       request :get_error_page
       request :set_error_page
       request :remove_error_page
+      request :get_stats
 
       module Shared
 
@@ -119,8 +120,8 @@ module Fog
           @connection = Fog::Connection.new(endpoint_uri.to_s, @persistent, @connection_options)
         end
 
-        def request(params, parse_json = true, &block)
-          super(params, parse_json, &block)
+        def request(params, parse_json = true)
+          super
         rescue Excon::Errors::NotFound => error
           raise NotFound.slurp(error, self)
         rescue Excon::Errors::BadRequest => error

data/lib/fog/rackspace/mock_data.rb

@@ -7,8 +7,9 @@ module Fog
       def data
         @@data ||= Hash.new do |hash, key|
           hash[key] = begin
+
             #Compute V2
-            flavor_id  = Fog.credentials[:rackspace_flavor_id].to_s ||= Fog::Mock.random_numbers(1)
+            flavor_id  = Fog.credentials[:rackspace_flavor_id] ||= '3'
             image_id   = Fog.credentials[:rackspace_image_id] ||= Fog::Rackspace::MockData.uuid
             image_name = Fog::Mock.random_letters(6)
             network_id = Fog::Rackspace::MockData.uuid
@@ -113,11 +114,72 @@ module Fog
               "extra_specs" => {},
             }
 
+            #AutoScale
+            launch_config = {
+              "args" => {
+                  "loadBalancers" => [
+                    {
+                      "port" => 8080,
+                      "loadBalancerId" => 9099
+                    }
+                  ],
+                  "server" => {
+                    "name" => "autoscale_server",
+                    "imageRef" => "0d589460-f177-4b0f-81c1-8ab8903ac7d8",
+                    "flavorRef" => "2",
+                    "OS-DCF =>diskConfig" => "AUTO",
+                    "metadata" => {
+                      "build_config" => "core",
+                      "meta_key_1" => "meta_value_1",
+                      "meta_key_2" => "meta_value_2"
+                    },
+                    "networks" => [
+                      {
+                        "uuid" => "11111111-1111-1111-1111-111111111111"
+                      },
+                      {
+                        "uuid" => "00000000-0000-0000-0000-000000000000"
+                      }
+                    ],
+                    "personality" => [
+                      {
+                        "path" => "/root/.csivh",
+                        "contents" => "VGhpcyBpcyBhIHRlc3QgZmlsZS4="
+                      }
+                    ]
+                  }
+                },
+                "type" => "launch_server"
+            }
+
+            group_config = {
+              "max_entities" => 10,
+              "cooldown" => 360,
+              "name" => "testscalinggroup198547",
+              "min_entities" => 0,
+              "metadata" => {
+                "gc_meta_key_2" => "gc_meta_value_2",
+                "gc_meta_key_1" => "gc_meta_value_1"
+              }
+            }
+
+            policy = {
+              "cooldown" => 0,
+              "type" => "webhook",
+              "name" => "scale up by 1",
+              "change" => 1
+            }
+
+            webhook = {
+              "name" => "webhook name",
+              "metadata" => {'foo' => 'bar'}
+            }
+
             mock_data = {
               #Compute V2
-              :flavors  => Hash.new { |h,k| h[k] = flavor  unless k == NOT_FOUND_ID },
-              :images   => Hash.new { |h,k| h[k] = image   unless k == NOT_FOUND_ID },        
-              :networks => Hash.new { |h,k| h[k] = network unless k == NOT_FOUND_ID },
+              :flavors  => Hash.new { |h,k| h[k] = flavor  unless [NOT_FOUND_ID, '0'].include?(k) },
+              :images   => Hash.new { |h,k| h[k] = image   unless [NOT_FOUND_ID, '0'].include?(k) },
+              :networks => Hash.new { |h,k| h[k] = network unless [NOT_FOUND_ID, '0'].include?(k) },
               :keys     => [],
               :keypair  => key_pair,
               :keypairs => [],
@@ -128,6 +190,9 @@ module Fog
               :snapshots          => {},
               :volume_attachments => [],
               :volume_types       => {volume_type1_id => volume_type1, volume_type2_id => volume_type2},
+
+              #Autoscale
+              :autoscale_groups => {}
             }
             
             # seed with initial data

data/lib/fog/rackspace/models/auto_scale/group.rb

@@ -0,0 +1,207 @@
+require 'fog/core/model'
+require 'fog/rackspace/models/auto_scale/group_config'
+require 'fog/rackspace/models/auto_scale/launch_config'
+require 'fog/rackspace/models/auto_scale/policies'
+
+module Fog
+  module Rackspace
+    class AutoScale
+      class Group < Fog::Model
+        
+        # @!attribute [r] id
+        # @return [String] The autoscale group's id
+        identity :id
+
+        # @!attribute [r] links
+        # @return [Array] group links.
+        attribute :links
+
+        # Gets the group configuration for this autoscale group. The configuration describes the 
+        # minimum number of entities in the group, the maximum number of entities in the group, 
+        # the global cooldown time for the group, and other metadata.
+        #
+        # @return [Fog::Rackspace::AutoScale::GroupConfiguration] group_config if found
+        #
+        # @raise [Fog::Rackspace::AutoScale:::NotFound] - HTTP 404
+        # @raise [Fog::Rackspace::AutoScale:::BadRequest] - HTTP 400
+        # @raise [Fog::Rackspace::AutoScale:::InternalServerError] - HTTP 500
+        # @raise [Fog::Rackspace::AutoScale:::ServiceError]
+        #
+        # @see http://docs.rackspace.com/cas/api/v1.0/autoscale-devguide/content/GET_getGroupConfig_v1.0__tenantId__groups__groupId__config_Configurations.html
+        def group_config
+          if attributes[:group_config].nil?
+            data = service.get_group_config(identity)
+            attributes[:group_config] = load_model('GroupConfig', data.body['groupConfiguration'])
+          end
+          attributes[:group_config]
+        end
+
+        # Sets the configuration when this object is populated.
+        #
+        # @param object [Hash<String, String>] Object which will stock the object
+        def group_config=(object = {})
+          if object.is_a?(Hash)
+            attributes[:group_config] = load_model('GroupConfig', object)
+          else
+            attributes[:group_config] = object
+          end
+        end
+
+        # Gets the launch configuration for this autoscale group. The launch configuration describes 
+        # the details of how to create a server, from what image to create a server, which load balancers 
+        # to join the server to, which networks to add the server to, and other metadata.
+        #
+        # @return [Fog::Rackspace::AutoScale::LaunchConfiguration] group_config if found
+        #
+        # @raise [Fog::Rackspace::AutoScale:::NotFound] - HTTP 404
+        # @raise [Fog::Rackspace::AutoScale:::BadRequest] - HTTP 400
+        # @raise [Fog::Rackspace::AutoScale:::InternalServerError] - HTTP 500
+        # @raise [Fog::Rackspace::AutoScale:::ServiceError]
+        #
+        # @see http://docs.rackspace.com/cas/api/v1.0/autoscale-devguide/content/GET_getLaunchConfig_v1.0__tenantId__groups__groupId__launch_Configurations.html
+        def launch_config
+          if attributes[:launch_config].nil?
+            data = service.get_launch_config(identity)
+            attributes[:launch_config] = load_model('LaunchConfig', data.body['launchConfiguration'])
+          end
+          attributes[:launch_config]
+        end
+
+        # Sets the configuration when this object is populated.
+        #
+        # @param object [Hash<String, String>] Object which will stock the object
+        def launch_config=(object={})
+          if object.is_a?(Hash)
+            attributes[:launch_config] = load_model('LaunchConfig', object)
+          else
+            attributes[:launch_config] = object
+          end
+        end
+
+        # For the specified autoscaling group, this operation returns a list of the scaling policies 
+        # that are available to the group. Each policy is described in terms of an ID, name, type, 
+        # adjustment, cooldown time, and links.
+        #
+        # @return [Fog::Rackspace::AutoScale::Policies] policies
+        #
+        # @see http://docs.rackspace.com/cas/api/v1.0/autoscale-devguide/content/GET_getPolicies_v1.0__tenantId__groups__groupId__policies_Policies.html
+        def policies
+          @policies ||= load_model('Policies')
+        end
+
+        # Creates group
+        # * requires attributes: :launch_config, :group_config, :policies
+        # 
+        # @return [Boolean] returns true if group is being created
+        #
+        # @raise [Fog::Rackspace::AutoScale:::NotFound] - HTTP 404
+        # @raise [Fog::Rackspace::AutoScale:::BadRequest] - HTTP 400
+        # @raise [Fog::Rackspace::AutoScale:::InternalServerError] - HTTP 500
+        # @raise [Fog::Rackspace::AutoScale:::ServiceError]
+        #
+        # @see Groups#create
+        # @see http://docs.rackspace.com/cas/api/v1.0/autoscale-devguide/content/POST_createGroup_v1.0__tenantId__groups_Groups.html   
+        def save
+          requires :launch_config, :group_config, :policies
+          raise Fog::Errors::Error.new("You should update launch_config and group_config directly") if persisted?
+
+          launch_config_hash = {
+            'args' => launch_config.args,
+            'type' => launch_config.type
+          }
+          group_config_hash = {
+            'name' => group_config.name,
+            'cooldown' => group_config.cooldown, 
+            'maxEntities' => group_config.max_entities,
+            'minEntities' => group_config.min_entities
+          }
+          group_config_hash['metadata'] = group_config.metadata if group_config.metadata
+
+          data = service.create_group(launch_config_hash, group_config_hash, policies)
+          merge_attributes(data.body['group'])
+          true
+        end
+
+        # Destroy the group
+        #
+        # @return [Boolean] returns true if group has started deleting
+        #
+        # @raise [Fog::Rackspace::AutoScale:::NotFound] - HTTP 404
+        # @raise [Fog::Rackspace::AutoScale:::BadRequest] - HTTP 400
+        # @raise [Fog::Rackspace::AutoScale:::InternalServerError] - HTTP 500
+        # @raise [Fog::Rackspace::AutoScale:::ServiceError]
+        #
+        # @see http://docs.rackspace.com/cas/api/v1.0/autoscale-devguide/content/DELETE_deleteGroup_v1.0__tenantId__groups__groupId__Groups.html
+        def destroy
+          requires :identity
+          service.delete_group(identity)
+          true
+        end
+
+        # Get the current state of the autoscale group
+        #
+        # @return [String] the state of the group
+        #
+        # @raise [Fog::Rackspace::AutoScale:::NotFound] - HTTP 404
+        # @raise [Fog::Rackspace::AutoScale:::BadRequest] - HTTP 400
+        # @raise [Fog::Rackspace::AutoScale:::InternalServerError] - HTTP 500
+        # @raise [Fog::Rackspace::AutoScale:::ServiceError]
+        #
+        # @see http://docs.rackspace.com/cas/api/v1.0/autoscale-devguide/content/GET_getGroupState_v1.0__tenantId__groups__groupId__state_Groups.html
+        def state
+          requires :identity
+          data = service.get_group_state(identity)
+          data.body['group']
+        end
+
+        # This operation pauses all execution of autoscaling policies.
+        # 
+        # @note NOT IMPLEMENTED YET
+        # @return [Boolean] returns true if paused
+        #
+        # @raise [Fog::Rackspace::AutoScale:::NotFound] - HTTP 404
+        # @raise [Fog::Rackspace::AutoScale:::BadRequest] - HTTP 400
+        # @raise [Fog::Rackspace::AutoScale:::InternalServerError] - HTTP 500
+        # @raise [Fog::Rackspace::AutoScale:::ServiceError]
+        #
+        # @see http://docs.rackspace.com/cas/api/v1.0/autoscale-devguide/content/POST_pauseGroup_v1.0__tenantId__groups__groupId__pause_Groups.html
+        def pause
+          requires :identity
+          data = service.pause_group_state(identity)
+          true
+        end
+
+        # This operation resumes all execution of autoscaling policies.
+        # 
+        # @note NOT IMPLEMENTED YET
+        # @return [Boolean] returns true if resumed
+        #
+        # @raise [Fog::Rackspace::AutoScale:::NotFound] - HTTP 404
+        # @raise [Fog::Rackspace::AutoScale:::BadRequest] - HTTP 400
+        # @raise [Fog::Rackspace::AutoScale:::InternalServerError] - HTTP 500
+        # @raise [Fog::Rackspace::AutoScale:::ServiceError]
+        #
+        # @see http://docs.rackspace.com/cas/api/v1.0/autoscale-devguide/content/POST_resumeGroup_v1.0__tenantId__groups__groupId__resume_Groups.html
+        def resume
+          requires :identity
+          data = service.resume_group_state(identity)
+          true
+        end
+
+        private
+
+        def load_model(class_name, attrs = nil)
+          model = Fog::Rackspace::AutoScale.const_get(class_name).new({
+            :service => @service,
+            :group   => self
+          })
+          if service && attrs
+            model.merge_attributes(attrs)
+          end
+          model
+        end
+
+      end
+    end
+  end
+end