fog 1.18.0 → 1.19.0

data/lib/fog/rackspace/examples/queues/claim_messages.rb

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+
+# This example demonstrates claiming messages with the Rackpace Open Cloud
+
+require 'rubygems' #required for Ruby 1.8.x
+require 'fog'
+
+def get_user_input(prompt)
+  print "#{prompt}: "
+  gets.chomp
+end
+
+def select_queue(queues)
+  abort "\nThere are not any queues the Chicago region. Try running create_queue.rb\n\n" if queues.empty?
+
+  puts "\nSelect Queue To Delete:\n\n"
+  queues.each_with_index do |queue, i|
+    puts "\t #{i}. #{queue.name}"
+  end
+
+  delete_str = get_user_input "\nEnter Queue Number"
+  queues[delete_str.to_i]
+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 Queue Service
+service = Fog::Rackspace::Queues.new({
+  :rackspace_username   => rackspace_username,
+  :rackspace_api_key    => rackspace_api_key,
+  :rackspace_region => :ord #Use Chicago Region
+})
+
+# retrieve list of queues
+queues = service.queues
+
+# prompt for queue
+queue = select_queue(queues)
+
+# prompt for number of messages to claim
+num_claims = get_user_input "Enter Number of Messages to Claim"
+
+# Claim messages
+claim = queue.claims.create :ttl => 300, :grace => 100, :limit => num_claims
+
+puts "The following messages have been claimed for the next 5 minutes [#{claim.id}]"
+
+claim.messages.each do |message|
+  puts "\t[#{message.id}] #{message.body[0..50]}"
+end

data/lib/fog/rackspace/examples/queues/create_queue.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+# This example demonstrates creating a queue with the Rackpace Open Cloud
+
+require 'rubygems' #required for Ruby 1.8.x
+require 'fog'
+
+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 Queue Service
+service = Fog::Rackspace::Queues.new({
+  :rackspace_username   => rackspace_username,
+  :rackspace_api_key    => rackspace_api_key,
+  :rackspace_region => :ord #Use Chicago Region
+})
+
+#prompt for queue name
+queue_name = get_user_input "Enter name for queue"
+
+begin
+  # create queue
+  queue = service.queues.create :name => queue_name
+  puts "Queue #{queue_name} was successfully created"
+
+  puts "To delete the queue please execute the delete_queue.rb script\n\n"
+rescue Fog::Rackspace::Queues::ServiceError => e
+  if e.status_code == 204
+    puts "Queue #{queue_name} already exists"
+  end
+end

data/lib/fog/rackspace/examples/queues/delete_message.rb

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+
+# This example demonstrates deleting a message with the Rackpace Open Cloud
+
+require 'rubygems' #required for Ruby 1.8.x
+require 'fog'
+
+def get_user_input(prompt)
+  print "#{prompt}: "
+  gets.chomp
+end
+
+def select_queue(queues)
+  abort "\nThere are not any queues in the Chicago region. Try running create_queue.rb\n\n" if queues.empty?
+
+  puts "\nSelect Queue To Delete:\n\n"
+  queues.each_with_index do |queue, i|
+    puts "\t #{i}. #{queue.name}"
+  end
+
+  delete_str = get_user_input "\nEnter Queue Number"
+  queues[delete_str.to_i]
+end
+
+def select_message(messages)
+  abort "\nThere are not any messages in the Chicago region. Try running post_message.rb\n\n" if messages.empty?
+
+  puts "\nSelect Message To Delete:\n\n"
+  messages.each_with_index do |message, i|
+    puts "\t #{i}. [#{message.id}] #{message.body[0..50]}"
+  end
+
+  delete_str = get_user_input "\nEnter Message Number"
+  messages[delete_str.to_i]
+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 Queue Service
+service = Fog::Rackspace::Queues.new({
+  :rackspace_username   => rackspace_username,
+  :rackspace_api_key    => rackspace_api_key,
+  :rackspace_region => :ord #Use Chicago Region
+})
+
+# retrieve list of queues
+queues = service.queues
+
+# prompt for queue
+queue = select_queue(queues)
+
+#retrieve list of messages
+messages = queue.messages
+
+# prompt for message
+message = select_message(messages)
+
+# delete message
+message.destroy
+
+puts "\nMessage #{message.id} has been destroyed\n"

data/lib/fog/rackspace/examples/queues/delete_queue.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+
+# This example demonstrates deleting a queue with the Rackpace Open Cloud
+
+require 'rubygems' #required for Ruby 1.8.x
+require 'fog'
+
+def get_user_input(prompt)
+  print "#{prompt}: "
+  gets.chomp
+end
+
+def select_queue(queues)
+  abort "\nThere are not any queues to delete in the Chicago region. Try running create_queue.rb\n\n" if queues.empty?
+
+  puts "\nSelect Queue To Delete:\n\n"
+  queues.each_with_index do |queue, i|
+    puts "\t #{i}. #{queue.name}"
+  end
+
+  delete_str = get_user_input "\nEnter Queue Number"
+  queues[delete_str.to_i]
+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 Queue Service
+service = Fog::Rackspace::Queues.new({
+  :rackspace_username   => rackspace_username,
+  :rackspace_api_key    => rackspace_api_key,
+  :rackspace_region => :ord #Use Chicago Region
+})
+
+# retrieve list of queues
+queues = service.queues
+
+# prompt for queue to delete
+queue = select_queue(queues)
+
+# delete queue
+queue.destroy
+
+puts "\nQueue #{queue.name} has been destroyed\n"

data/lib/fog/rackspace/examples/queues/list_messages.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+
+# This example demonstrates listing messages in a queue with the Rackpace Open Cloud
+
+require 'rubygems' #required for Ruby 1.8.x
+require 'fog'
+
+def get_user_input(prompt)
+  print "#{prompt}: "
+  gets.chomp
+end
+
+def get_user_boolean(prompt)
+  str = get_user_input(prompt)
+  return false unless str
+  str.match(/y(es)?/i) ? true : false
+end
+
+def select_queue(queues)
+  abort "\nThere are not any queues to post a message to in the Chicago region. Try running create_queue.rb\n\n" if queues.empty?
+
+  puts "\nSelect Queue:\n\n"
+  queues.each_with_index do |queue, i|
+    puts "\t #{i}. #{queue.name}"
+  end
+
+  delete_str = get_user_input "\nEnter Queue Number"
+  queues[delete_str.to_i]
+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 Queue Service
+service = Fog::Rackspace::Queues.new({
+  :rackspace_username   => rackspace_username,
+  :rackspace_api_key    => rackspace_api_key,
+  :rackspace_region => :ord #Use Chicago Region
+})
+
+# retrieve list of queues
+queues = service.queues
+
+# prompt for queue to delete
+queue = select_queue(queues)
+
+queue.messages.echo = get_user_boolean "Do you want to include your own messages? [y/N]"
+
+queue.messages.include_claimed = get_user_boolean "Do you want to include claimed messages? [y/N]"
+
+puts "\n\nThe following messages are in the '#{queue.name}' queue:\n\n"
+
+queue.messages.each do |message|
+  puts message.inspect
+end

data/lib/fog/rackspace/examples/queues/post_message.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+
+# This example demonstrates posting a message to a queue with the Rackpace Open Cloud
+
+require 'rubygems' #required for Ruby 1.8.x
+require 'fog'
+
+def get_user_input(prompt)
+  print "#{prompt}: "
+  gets.chomp
+end
+
+def select_queue(queues)
+  abort "\nThere are not any queues to post a message to in the Chicago region. Try running create_queue.rb\n\n" if queues.empty?
+
+  puts "\nSelect Queue:\n\n"
+  queues.each_with_index do |queue, i|
+    puts "\t #{i}. #{queue.name}"
+  end
+
+  delete_str = get_user_input "\nEnter Queue Number"
+  queues[delete_str.to_i]
+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 Queue Service
+service = Fog::Rackspace::Queues.new({
+  :rackspace_username   => rackspace_username,
+  :rackspace_api_key    => rackspace_api_key,
+  :rackspace_region => :ord #Use Chicago Region
+})
+
+# retrieve list of queues
+queues = service.queues
+
+# prompt for queue to delete
+queue = select_queue(queues)
+
+# prompt for queue message
+message = get_user_input "Enter Queue Message"
+
+# time to live TTL = 1 hour
+ttl = 3600
+
+# post message to queue
+queue.messages.create :body => message, :ttl => ttl
+
+puts "The message has been successfully posted"

data/lib/fog/rackspace/models/compute_v2/key_pairs.rb

@@ -24,7 +24,7 @@ module Fog
         end
 
         # Fetch keypair details
-        # @param  [String] key_name: name of the key to request
+        # @param  [String] key_name name of the key to request
         # @return [Fog::Compute::RackspaceV2::Keypair] the requested keypair or 'nil' when not found
         # @raise  [Fog::Compute::RackspaceV2::BadRequest]
         # @raise  [Fog::Compute::RackspaceV2::InternalServerError]

data/lib/fog/rackspace/models/compute_v2/server.rb

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 require 'fog/compute/models/server'
 require 'fog/rackspace/models/compute_v2/metadata'
 
@@ -521,13 +522,14 @@ module Fog
         # @see Servers#bootstrap
         def setup(credentials = {})
           requires :public_ip_address, :identity, :public_key, :username
-          Fog::SSH.new(public_ip_address, username, credentials).run([
+          commands = [
             %{mkdir .ssh},
             %{echo "#{public_key}" >> ~/.ssh/authorized_keys},
-            %{passwd -l #{username}},
+            password_lock,
             %{echo "#{Fog::JSON.encode(attributes)}" >> ~/attributes.json},
             %{echo "#{Fog::JSON.encode(metadata)}" >> ~/metadata.json}
-          ])
+          ].compact
+          Fog::SSH.new(public_ip_address, username, credentials).run(commands)
         rescue Errno::ECONNREFUSED
           sleep(1)
           retry
@@ -538,6 +540,10 @@ module Fog
         def adminPass=(new_admin_pass)
           @password = new_admin_pass
         end
+
+        def password_lock
+          "passwd -l #{username}" unless attributes[:no_passwd_lock] 
+        end
       end
     end
   end

data/lib/fog/rackspace/models/compute_v2/servers.rb

@@ -29,8 +29,8 @@ module Fog
         # @raise [Fog::Compute::RackspaceV2::BadRequest] - HTTP 400
         # @raise [Fog::Compute::RackspaceV2::InternalServerError] - HTTP 500
         # @raise [Fog::Compute::RackspaceV2::ServiceError]
-        # @note This method is incompatible with Cloud Servers utlizing RackConnect. RackConnect users
-        #     should use server personalization to install keys.  Please see Server#personality for more information.
+        # @note This method is compatible with Cloud Servers utlizing RackConnect ***if and only if***
+        #       provided the attribute "no_passwd_lock" set to *true*.
         # @example
         #   service.servers.bootstrap :name => 'bootstrap-server',
         #                             :flavor_id => service.flavors.first.id,

data/lib/fog/rackspace/models/identity/service_catalog.rb

@@ -8,36 +8,51 @@ module Fog
         
         def initialize(attributes)
           @service = attributes.delete(:service)
-          @catalog = {}
+          @catalog = attributes.delete(:catalog) || {}
         end
         
         def services
-          catalog.keys
+          catalog.collect {|s| s["name"]}
         end
-        
-        def get_endpoints(service_type)
-          service_type = service_type.is_a?(String) ? service_type.to_sym : service_type
-          catalog[service_type]
+
+        def get_endpoints(service_name, service_net=false)
+          h = catalog.find {|service| service["name"] == service_name.to_s}
+          return {} unless h
+          key = network_type_key(service_net)
+          h["endpoints"].select {|e| e[key]}
         end
+
         
-        def display_service_regions(service_type)
-          endpoints = get_endpoints(service_type)
-          endpoints.collect { |k,v| ":#{k}" }.join(", ")
+        def display_service_regions(service_name, service_net=false)
+          endpoints = get_endpoints(service_name, service_net)
+          regions = endpoints.collect do |e|
+            e["region"] ? ":#{e["region"].downcase}" : ":global"
+          end
+          regions.join(", ")
         end
         
-        def get_endpoint(service_type, region=nil)
-          endpoint = get_endpoints(service_type)
-          raise "Unable to locate endpoint for service #{service_type}" unless endpoint
+        def get_endpoint(service_name, region=nil, service_net=false)
+          service_region = region_key(region)
+
+          network_type = network_type_key(service_net)
+
+          endpoints = get_endpoints(service_name, service_net)
+          raise "Unable to locate endpoint for service #{service_name}" if endpoints.empty?
+
+          if endpoints.size > 1 && region.nil?
+            raise "There are multiple endpoints available for #{service_name}. Please specify one of the following regions: #{display_service_regions(service_name)}."
+          end
 
-          return endpoint if endpoint.is_a?(String) #There is only one endpoint for service
+          # select multiple endpoints
+          endpoint = endpoints.find {|e| matching_region?(e, service_region) }
+          return endpoint[network_type] if endpoint && endpoint[network_type]
 
-          unless region
-            raise "There are multiple endpoints available for #{service_type}. Please specify one of the following regions: #{display_service_regions(service_type)}."
+          # endpoint doesnt have region
+          if endpoints.size == 1 && matching_region?(endpoints[0], "GLOBAL")
+            return endpoints[0][network_type]
           end
-          region = region.is_a?(String) ? region.to_sym : region
-          endpoint = get_endpoints(service_type)[region]
-          raise "Unknown region :#{region} for service #{service_type}. Please use one of the following regions: #{display_service_regions(service_type)}" unless endpoint
-          endpoint
+
+          raise "Unknown region :#{region} for service #{service_name}. Please use one of the following regions: #{display_service_regions(service_name)}"
         end
         
         def reload
@@ -47,52 +62,22 @@ module Fog
         end
                 
         def self.from_response(service, hash)
-          service_catalog = ServiceCatalog.new :service => service
-          begin
-            services = hash["access"]["serviceCatalog"]
-            services.each do |serv|
-              name = serv["name"] ? serv["name"].to_sym : nil
-              next unless name
-              service_catalog.send(:add_endpoints, name, serv)
-            end
-          rescue => e
-            Logger.warning "Exception occurred while loading service catalog - #{e.inspect}"
-            Logger.warning "Unable to load service catalog. Please specify endpoints manually"
-          end
-          service_catalog
+          ServiceCatalog.new :service => service, :catalog => hash["access"]["serviceCatalog"]
         end
 
         private
         
-        def add_endpoints(service_name, hash)
-          begin
-            endpoints = hash["endpoints"]
-            if endpoints.size == 1
-              catalog[service_name] = endpoints[0]["publicURL"].freeze
-            else
-              catalog[service_name] = endpoints_from_array(service_name, endpoints)
-            end
-          rescue => e
-            Logger.warning "Exception occurred while loading #{service_name} service endpoints - #{e.inspect}"
-            Logger.warning "Unable to load service endpoints for #{service_name}. Please specify #{service_name} endpoints manually."
-          end
+        def network_type_key(service_net)
+          service_net ? "internalURL" : "publicURL"
+        end
+
+        def matching_region?(h, region)
+          region_key(h["region"]) == region
         end
         
-        def endpoints_from_array(service_name, endpoints)
-          hash = {}
-          endpoints.each do |endpoint|
-            begin
-              region_name = endpoint["region"]
-              region = region_name ? region_name.downcase.to_sym : :global
-              url = endpoint["publicURL"].freeze
-              hash[region] = url
-            rescue => e
-              Logger.warning "Exception occurred while loading #{service_name} service endpoints - #{e.inspect}"
-              Logger.warning "Unable to parse #{service_name} endpoint - #{endpoint}"
-              Logger.warning "You may need to specify #{service_name} endpoints manually."
-            end
-          end
-          hash
+        def region_key(region)
+          return region.to_s.upcase if region.is_a? Symbol
+          (region.nil? || region.empty?) ? "GLOBAL" : region.to_s.upcase
         end
         
       end