fog-rackspace 0.1.0

data/lib/fog/rackspace/examples/storage/upload_file.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+# This example demonstrates creating a file on the CDN network 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 Cloud Files service
+service = Fog::Storage.new({
+  :provider             => 'Rackspace',
+  :rackspace_username   => rackspace_username,
+  :rackspace_api_key    => rackspace_api_key,
+  :rackspace_region => :ord #Use Chicago Region
+  })
+
+# prompt for directory name
+directory_name = get_user_input "\nEnter name of directory to create"
+
+# create directory with CDN service
+directory = service.directories.create :key => directory_name, :public => true
+
+# upload file
+upload_file = File.join(File.dirname(__FILE__), "lorem.txt")
+file = directory.files.create :key => 'sample.txt', :body => File.open(upload_file, "r")
+
+puts "You should be able to view this file via CDN at #{file.public_url}"
+puts "To delete the container and associated file please execute the delete_directory.rb script\n\n"

data/lib/fog/rackspace/examples/storage/upload_large_files.rb

@@ -0,0 +1,101 @@
+#!/usr/bin/env ruby
+
+# This example demonstrates uploading large files in segments
+
+require 'rubygems' #required for Ruby 1.8.x
+require 'fog'
+
+# Size of segment. The Rackspace cloud currently requires files larger than 5GB to be segmented so we will choose 5GB -1 for a size
+# http://docs.rackspace.com/files/api/v1/cf-devguide/content/Large_Object_Creation-d1e2019.html
+SEGMENT_LIMIT = 5368709119.0
+
+# Size of buffer to use for transfers. Use Excon's default chunk size and if that's not avaliable we will default to 1 MB
+BUFFER_SIZE = Excon.defaults[:chunk_size] || 1024 * 1024
+
+def get_user_input(prompt)
+  print "\n#{prompt}: "
+  gets.chomp
+end
+
+def select_directory(directories)
+  abort "\nThere are not any directories in the Chicago region. Try running create_private_directory.rb\n\n" if directories.empty?
+
+  puts "\nSelect Directory:\n\n"
+  directories.each_with_index do |dir, i|
+    puts "\t #{i}. #{dir.key} [#{dir.count} objects]"
+  end
+
+  select_str = get_user_input "Enter Directory Number"
+  directories[select_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 Cloud Files service
+service = Fog::Storage.new({
+  :provider             => 'Rackspace',
+  :rackspace_username   => rackspace_username,
+  :rackspace_api_key    => rackspace_api_key,
+  :rackspace_region     => :ord
+  })
+
+# retrieve directories with files
+directories = service.directories
+
+# prompt for directory
+directory = select_directory(directories)
+
+# prompt for file name
+file_name = get_user_input "Enter full path of file to upload"
+segment_name = File.basename(file_name)
+
+File.open(file_name) do |f|
+  num_segments = (f.stat.size / SEGMENT_LIMIT).round + 1
+  puts "\nThis upload of '#{file_name}' will require #{num_segments} segment(s) and 1 manifest file\n"
+
+  segment = 0
+   until f.eof?
+     segment += 1
+     offset = 0
+
+     # upload segment to cloud files
+     segment_suffix = segment.to_s.rjust(10, '0')
+     print "\n\tUploading segment #{segment_suffix} "
+     service.put_object(directory.key, "#{segment_name}/#{segment_suffix}", nil) do
+       if offset <= SEGMENT_LIMIT - BUFFER_SIZE
+         print "."
+         buf = f.read(BUFFER_SIZE).to_s
+         offset += buf.size
+         buf
+       else
+         ''
+       end
+     end
+   end
+ end
+
+puts "\n\n\tWriting manifest #{segment_name}\n\n"
+service.put_object_manifest(directory.key, segment_name, 'X-Object-Manifest' => "#{directory.key}/#{segment_name}/" )
+
+puts <<-NOTE
+You should now be able to download #{segment_name} from the cloud control panel or using the following code:
+
+    directory = service.directories.get('#{directory.key}')
+    File.open('downloaded_#{segment_name}', 'w') do | f |
+      directory.files.get('#{segment_name}') do | data, remaining, content_length |
+        print "."
+        f.write data
+      end
+    end
+
+NOTE

data/lib/fog/rackspace/identity.rb

@@ -0,0 +1,83 @@
+require 'fog/rackspace/core'
+
+module Fog
+  module Rackspace
+    class Identity < Fog::Service
+      US_ENDPOINT = 'https://identity.api.rackspacecloud.com/v2.0'
+      UK_ENDPOINT = 'https://lon.identity.api.rackspacecloud.com/v2.0'
+
+      requires :rackspace_username, :rackspace_api_key
+      recognizes :rackspace_auth_url, :rackspace_region
+
+      model_path 'fog/rackspace/models/identity'
+      model :user
+      collection :users
+      model :role
+      collection :roles
+      model :credential
+      collection :credentials
+      model :tenant
+      collection :tenants
+      model :service_catalog
+
+      request_path 'fog/rackspace/requests/identity'
+      request :create_token
+
+      request :list_users
+      request :list_user_roles
+      request :list_credentials
+      request :list_tenants
+      request :get_user_by_id
+      request :get_user_by_name
+      request :create_user
+      request :update_user
+      request :delete_user
+
+      module Common
+        attr_reader :service_catalog, :auth_token
+
+        def authenticate(options={})
+          data = self.create_token(@rackspace_username, @rackspace_api_key).body
+          @service_catalog = ServiceCatalog.from_response(self, data)
+          @auth_token = data['access']['token']['id']
+        end
+
+        def apply_options(options)
+          @rackspace_username = options[:rackspace_username]
+          @rackspace_api_key = options[:rackspace_api_key]
+          @rackspace_region = options[:rackspace_region]
+          @rackspace_auth_url = options[:rackspace_auth_url] || US_ENDPOINT
+
+          @uri = URI.parse(@rackspace_auth_url)
+          @host = @uri.host
+          @path = @uri.path
+          @port = @uri.port
+          @scheme = @uri.scheme
+          @persistent = options[:persistent] || false
+          @connection_options = options[:connection_options] || {}
+        end
+      end
+
+      class Mock < Fog::Rackspace::Service
+        include Common
+
+        def initialize(options={})
+          apply_options(options)
+
+          authenticate
+        end
+      end
+
+      class Real < Fog::Rackspace::Service
+        include Common
+
+        def initialize(options={})
+          apply_options(options)
+          @connection = Fog::Core::Connection.new(@uri.to_s, @persistent, @connection_options)
+
+          authenticate
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/load_balancers.rb

@@ -0,0 +1,206 @@
+require 'fog/rackspace/core'
+
+module Fog
+  module Rackspace
+    class LoadBalancers < Fog::Service
+      include Fog::Rackspace::Errors
+
+      #These references exist for backwards compatibility
+      class ServiceError < Fog::Rackspace::Errors::ServiceError; end
+      class InternalServerError < Fog::Rackspace::Errors::InternalServerError; end
+      class BadRequest < Fog::Rackspace::Errors::BadRequest; end
+
+      DFW_ENDPOINT = 'https://dfw.loadbalancers.api.rackspacecloud.com/v1.0'
+      ORD_ENDPOINT = 'https://ord.loadbalancers.api.rackspacecloud.com/v1.0'
+      LON_ENDPOINT = 'https://lon.loadbalancers.api.rackspacecloud.com/v1.0'
+
+      requires :rackspace_api_key, :rackspace_username
+      recognizes :rackspace_auth_url
+      recognizes :rackspace_auth_token
+      recognizes :rackspace_lb_endpoint
+      recognizes :rackspace_load_balancers_url
+      recognizes :rackspace_region
+
+      model_path 'fog/rackspace/models/load_balancers'
+      collection :load_balancers
+      model :load_balancer
+      collection :nodes
+      model :node
+      collection :virtual_ips
+      model :virtual_ip
+      collection :access_rules
+      model :access_rule
+
+      request_path 'fog/rackspace/requests/load_balancers'
+      request :get_ssl_termination
+      request :set_ssl_termination
+      request :remove_ssl_termination
+      request :create_load_balancer
+      request :get_load_balancer
+      request :list_load_balancers
+      request :update_load_balancer
+      request :delete_load_balancer
+      request :create_node
+      request :list_nodes
+      request :get_node
+      request :update_node
+      request :delete_node
+      request :delete_nodes
+      request :create_virtual_ip
+      request :list_virtual_ips
+      request :delete_virtual_ip
+      request :list_protocols
+      request :list_algorithms
+      request :get_connection_logging
+      request :set_connection_logging
+      request :get_content_caching
+      request :set_content_caching
+      request :create_access_rule
+      request :list_access_rules
+      request :delete_access_rule
+      request :delete_all_access_rules
+      request :get_session_persistence
+      request :set_session_persistence
+      request :remove_session_persistence
+      request :get_connection_throttling
+      request :remove_connection_throttling
+      request :set_connection_throttling
+      request :get_monitor
+      request :set_monitor
+      request :remove_monitor
+      request :get_usage
+      request :get_load_balancer_usage
+      request :get_error_page
+      request :set_error_page
+      request :remove_error_page
+      request :get_stats
+
+      module Shared
+        def algorithms
+          list_algorithms.body['algorithms'].map { |i| i['name'] }
+        end
+
+        def protocols
+          list_protocols.body['protocols']
+        end
+
+        def usage(options = {})
+          get_usage(options).body
+        end
+      end
+
+      class Mock < Fog::Rackspace::Service
+        include Shared
+
+        def initialize(options={})
+          @rackspace_api_key = options[:rackspace_api_key]
+          @rackspace_username = options[:rackspace_username]
+          @rackspace_auth_url = options[:rackspace_auth_url]
+        end
+      end
+
+      class Real < Fog::Rackspace::Service
+        include Shared
+
+        def initialize(options={})
+          @rackspace_api_key = options[:rackspace_api_key]
+          @rackspace_username = options[:rackspace_username]
+          @rackspace_auth_url = options[:rackspace_auth_url]
+          @rackspace_must_reauthenticate = false
+          @connection_options     = options[:connection_options] || {}
+
+          setup_custom_endpoint(options)
+
+          authenticate
+
+          deprecation_warnings(options)
+
+          @persistent = options[:persistent] || false
+          @connection = Fog::Core::Connection.new(endpoint_uri.to_s, @persistent, @connection_options)
+        end
+
+        def request(params, parse_json = true)
+          super
+        rescue Excon::Errors::NotFound => error
+          raise NotFound.slurp(error, self)
+        rescue Excon::Errors::BadRequest => error
+          raise BadRequest.slurp(error, self)
+        rescue Excon::Errors::InternalServerError => error
+          raise InternalServerError.slurp(error, self)
+        rescue Excon::Errors::HTTPStatusError => error
+          raise ServiceError.slurp(error, self)
+        end
+
+        def authenticate(options={})
+          super({
+            :rackspace_api_key => @rackspace_api_key,
+            :rackspace_username => @rackspace_username,
+            :rackspace_auth_url => @rackspace_auth_url,
+            :connection_options => @connection_options
+          })
+        end
+
+        def service_name
+          :cloudLoadBalancers
+        end
+
+        def region
+          @rackspace_region
+        end
+
+        def endpoint_uri(service_endpoint_url=nil)
+          @uri = super(@rackspace_endpoint || service_endpoint_url, :rackspace_load_balancers_url)
+        end
+
+        private
+
+        def setup_custom_endpoint(options)
+          @rackspace_endpoint = Fog::Rackspace.normalize_url(options[:rackspace_load_balancers_url] || options[:rackspace_lb_endpoint])
+
+          if v2_authentication?
+            case @rackspace_endpoint
+            when DFW_ENDPOINT
+              @rackspace_endpoint = nil
+              @rackspace_region = :dfw
+            when ORD_ENDPOINT
+              @rackspace_endpoint = nil
+              @rackspace_region = :ord
+            when LON_ENDPOINT
+              @rackspace_endpoint = nil
+              @rackspace_region = :lon
+            else
+              # we are actually using a custom endpoint
+              @rackspace_region = options[:rackspace_region]
+            end
+          else
+            #if we are using auth1 and the endpoint is not set, default to DFW_ENDPOINT for historical reasons
+             @rackspace_endpoint ||= DFW_ENDPOINT
+          end
+        end
+
+        def deprecation_warnings(options)
+          Fog::Logger.deprecation("The :rackspace_lb_endpoint option is deprecated. Please use :rackspace_load_balancers_url for custom endpoints") if options[:rackspace_lb_endpoint]
+
+          if [DFW_ENDPOINT, ORD_ENDPOINT, LON_ENDPOINT].include?(@rackspace_endpoint) && v2_authentication?
+            regions = @identity_service.service_catalog.display_service_regions(service_name)
+            Fog::Logger.deprecation("Please specify region using :rackspace_region rather than :rackspace_endpoint. Valid regions for :rackspace_region are #{regions}.")
+          end
+        end
+
+        def append_tenant_v1(credentials)
+          account_id = credentials['X-Server-Management-Url'].match(/.*\/([\d]+)$/)[1]
+
+          endpoint = @rackspace_endpoint || credentials['X-Server-Management-Url'] || DFW_ENDPOINT
+          @uri = URI.parse(endpoint)
+          @uri.path = "#{@uri.path}/#{account_id}"
+        end
+
+        def authenticate_v1(options)
+          credentials = Fog::Rackspace.authenticate(options, @connection_options)
+          append_tenant_v1 credentials
+          @auth_token = credentials['X-Auth-Token']
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/mock_data.rb

@@ -0,0 +1,252 @@
+module Fog
+  module Rackspace
+    module MockData
+      NOT_FOUND_ID = "NOT-FOUND"
+
+      def data
+        @@data ||= Hash.new do |hash, key|
+          hash[key] = begin
+
+            #Compute V2
+            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
+            user_id    = Fog::Mock.random_numbers(6).to_s
+
+            flavor = {
+              "OS-FLV-EXT-DATA:ephemeral" => 4,
+              "disk"  => 20,
+              "id"    => flavor_id,
+              "links" => [
+                {
+                  "href" => "https://dfw.servers.api.rackspacecloud.com/v2/010101/flavors/#{flavor_id}",
+                  "rel"  => "self"
+                },
+                {
+                  "href" => "https://dfw.servers.api.rackspacecloud.com/010101/flavors/#{flavor_id}",
+                  "rel"  => "bookmark"
+                }
+              ],
+              "name"        => "512MB Standard Instance",
+              "ram"         => 512,
+              "rxtx_factor" => 2.0,
+              "swap"        => 512,
+              "vcpus"       => 1
+            }
+
+            image = {
+              "OS-DCF:diskConfig" => "AUTO",
+              "created" => "2012-02-28T19:38:57Z",
+              "id" => image_id,
+              "name" => image_name,
+              "links" => [
+                {
+                  "href" => "https://dfw.servers.api.rackspacecloud.com/v2/010101/images/#{image_id}",
+                  "rel"  => "self"
+                },
+                {
+                  "href" => "https://dfw.servers.api.rackspacecloud.com/010101/images/#{image_id}",
+                  "rel"  => "bookmark"
+                },
+                {
+                  "href" => "https://dfw.servers.api.rackspacecloud.com/010101/images/#{image_id}",
+                  "rel"  => "alternate",
+                  "type" => "application/vnd.openstack.image"
+                }
+              ],
+              "metadata" => {
+                "arch" => "x86-64",
+                "auto_disk_config" => "True",
+                "com.rackspace__1__build_core" => "1",
+                "com.rackspace__1__build_managed" => "0",
+                "com.rackspace__1__build_rackconnect" => "0",
+                "com.rackspace__1__options" => "0",
+                "com.rackspace__1__visible_core" => "1",
+                "com.rackspace__1__visible_managed" => "0",
+                "com.rackspace__1__visible_rackconnect" => "0",
+                "image_type" => "base",
+                "org.openstack__1__architecture" => "x64",
+                "org.openstack__1__os_distro" => "org.ubuntu",
+                "org.openstack__1__os_version" => "11.10",
+                "os_distro" => "ubuntu",
+                "os_type" => "linux",
+                "os_version" => "11.10",
+                "rax_managed" => "false",
+                "rax_options" => "0"
+              },
+              "minDisk"  => 10,
+              "minRam"   => 256,
+              "progress" => 100,
+              "status"   => "ACTIVE",
+              "updated"  => "2012-02-28T19:39:05Z"
+            }
+
+            network = {
+              'id' => network_id,
+              'label' => 'network label',
+              'cidr' => '192.168.0.0/24'
+            }
+
+            key_pair = {
+              'public_key'  => "ssh-rsa ".concat(Fog::Mock.random_letters(372)).concat(" Generated by Nova\n"),
+              'private_key' => "-----BEGIN RSA PRIVATE KEY-----\n".concat(Fog::Mock.random_letters(1635)).concat("\n-----END RSA PRIVATE KEY-----\n"),
+              'user_id'     => user_id,
+              'name'        => Fog::Mock.random_letters(32),
+              'fingerprint' => "00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00"
+            }
+
+            #Block Storage
+            volume_type1_id = Fog::Mock.random_numbers(3).to_s
+            volume_type2_id = Fog::Mock.random_numbers(3).to_s
+
+            volume_type1 = {
+              "id" => volume_type1_id,
+              "name" => "SATA",
+              "extra_specs" => {}
+            }
+
+            volume_type2 = {
+              "id" => volume_type2_id,
+              "name" => "SSD",
+              "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 [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 => [],
+              :servers  => {},
+
+              #Block Storage
+              :volumes            => {},
+              :snapshots          => {},
+              :volume_attachments => [],
+              :volume_types       => {volume_type1_id => volume_type1, volume_type2_id => volume_type2},
+
+              #Autoscale
+              :autoscale_groups => {}
+            }
+
+            # seed with initial data
+            mock_data[:flavors][flavor_id] = flavor
+            mock_data[:images][image_id] = image
+            mock_data[:networks][network_id] = network
+
+            mock_data
+          end
+        end[@rackspace_api_key]
+      end
+
+      def self.uuid
+        [8,4,4,4,12].map { |i| Fog::Mock.random_hex(i) }.join("-")
+      end
+
+      def self.ipv4_address
+        4.times.map { Fog::Mock.random_numbers(3) }.join(".")
+      end
+
+      def self.ipv6_address
+        8.times.map { Fog::Mock.random_hex(4) }.join(":")
+      end
+
+      def self.keep(hash, *keys)
+        {}.tap do |kept|
+          keys.each { |k| kept[k] = hash[k] if hash.key?(k) }
+        end
+      end
+
+      def self.slice(hash, *keys)
+        hash.dup.tap do |sliced|
+          keys.each { |k| sliced.delete(k) }
+        end
+      end
+
+      def self.zulu_time
+        Time.now.strftime("%Y-%m-%dT%H:%M:%SZ")
+      end
+
+      def self.stringify(message)
+        case message
+        when Symbol
+          message.to_s
+        when Hash
+          result = Hash.new
+          message.each do |key, value|
+            nk = stringify(key)
+            nv = stringify(value)
+            result[nk] = nv
+          end
+          result
+        else
+          message
+        end
+      end
+    end
+  end
+end