cloudlb 0.0.1

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/COPYING

@@ -0,0 +1,12 @@
+Unless otherwise noted, all files are released under the MIT license, exceptions contain licensing information in them.
+
+  Copyright (C) 2011 Rackspace US, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of Rackspace US, Inc. shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from Rackspace US, Inc.
+

data/README.rdoc

@@ -0,0 +1,66 @@
+= Rackspace Cloud Load Balancers
+
+== Description
+
+This is a Ruby interface into the Rackspace[http://rackspace.com/] {Cloud Load Balancers}[http://www.rackspace.com/cloud/blog/2011/02/24/rackspace-cloud-load-balancers-beta-now-available-for-all-cloud-customers/] service. Mission-critical web-based applications and workloads require high availability. Load balancing 
+distributes workloads across two or more servers, network links, and other resources to maximize 
+throughput, minimize response time and avoid overload. Rackspace Cloud Load Balancers allow you 
+to quickly load balance multiple Cloud Servers for optimal resource utilization.
+
+== Installation
+
+This source is available on Github[http://github.com/rackspace/ruby-cloudlb/] and the gem is available on RubyGems[http://rubygems.org/].  To install it, do
+
+  sudo gem install cloudlb
+  
+To use it in Bundler, add the following statement to your Gemfile
+
+  gem "cloudlb"
+  
+== RDOC Documentation
+
+Find the latest RDoc documentation for this library at http://rdoc.info/github/rackspace/ruby-cloudlb/master/frames
+
+== API Documentation
+
+This binding attempts to conform to the latest API specifications. For current API documentation, visit http://docs.rackspacecloud.com/api/
+
+== Examples
+
+See the class definitions for documentation on specific methods and operations.
+
+  require 'rubygems'
+  require 'cloudlb'
+
+  # Authenticate to the Rackspace Cloud, and choose to manage load balancers in the Dallas/Ft. Worth datacenter
+  lb = CloudLB::Connection.new(:username => "MY_USERNAME", :api_key => "MY_API_KEY", :region => :dfw)
+
+  # Show active load balancers
+  lb.list_load_balancers
+  => [
+    {:status=>"ACTIVE", :port=>80, :updated=>{:time=>"2011-02-25T03:14:49+0000"}, :created=>{:time=>"2010-12-02T20:30:49+0000"}, :protocol=>"HTTP", :algorithm=>"RANDOM", :virtualIps=>[{:type=>"PUBLIC", :id=>21, :ipVersion=>"IPV4", :address=>"174.143.139.1"}], :name=>"stage-rax-lb", :id=>1}, 
+    {:status=>"ACTIVE", :port=>80, :updated=>{:time=>"2011-02-25T15:31:16+0000"}, :created=>{:time=>"2011-02-25T01:11:31+0000"}, :protocol=>"HTTP", :algorithm=>"ROUND_ROBIN", :virtualIps=>[{:type=>"PUBLIC", :id=>38, :ipVersion=>"IPV4", :address=>"174.143.139.2"}], :name=>"Renamed LB", :id=>73}
+    ]
+    
+  # Select a load balancer
+  balancer = lb.get_load_balancer(1)
+  => #<CloudLB::Balancer:0x101d7ebf8 @status="ACTIVE", @port=80, @name="stage-rax-lb", ...>
+  
+  # Change the algorithm to round-robin
+  balancer.algorithm="ROUND_ROBIN"
+  => "ROUND_ROBIN"
+  
+  # Add a new node to the load balancer
+  node = balancer.create_node(:address => '192.168.0.1', :port => 80)
+  => #<CloudLB::Node:0x101d48c88 @status="ONLINE", @port=80, ...>
+  
+== Authors
+
+{H. Wade Minter}[https://github.com/minter/] <minter@lunenburg.org>
+
+== License
+
+See COPYING for license information.
+Copyright (c) 2011, Rackspace US, Inc.
+  
+  

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/cloudlb.gemspec

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+ 
+require 'cloudlb'
+ 
+Gem::Specification.new do |s|
+  s.name        = "cloudlb"
+  s.version     = CloudLB::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["H. Wade Minter"]
+  s.email       = ["minter@lunenburg.org"]
+  s.homepage    = "http://github.com/rackspace/ruby-cloudlb"
+  s.summary     = "Ruby API into the Rackspace Cloud Load Balancers product"
+  s.description = "A Ruby API to manage the Rackspace Cloud Load Balancers product"
+ 
+  s.required_rubygems_version = ">= 1.3.6"
+ 
+  s.add_runtime_dependency "typhoeus"
+  s.add_runtime_dependency "json"
+ 
+  s.files = [
+    "VERSION",
+    "COPYING",
+    ".gitignore",
+    "README.rdoc",
+    "cloudlb.gemspec",
+    "lib/cloudlb.rb",
+    "lib/cloudlb/authentication.rb",
+    "lib/cloudlb/balancer.rb",
+    "lib/cloudlb/connection.rb",
+    "lib/cloudlb/exception.rb",
+    "lib/cloudlb/node.rb",
+    "lib/cloudlb/health_monitor.rb",
+    "lib/cloudlb/connection_throttle.rb"
+  ]
+  s.require_path = 'lib'
+end

data/lib/cloudlb.rb

@@ -0,0 +1,98 @@
+#!/usr/bin/env ruby
+# 
+# == Cloud Load Balancers API
+# ==== Connects Ruby Applications to Rackspace's {Cloud Load Balancers service}[http://www.rackspacecloud.com/cloud_hosting_products/servers]
+# By H. Wade Minter <minter@lunenburg.org>
+#
+# See COPYING for license information.
+# Copyright (c) 2011, Rackspace US, Inc.
+# ----
+# 
+# === Documentation & Examples
+# To begin reviewing the available methods and examples, peruse the README.rodc file, or begin by looking at documentation for the 
+# CloudLB::Connection class.
+#
+# The CloudLB class is the base class.  Not much of note aside from housekeeping happens here.
+# To create a new CloudLB connection, use the CloudLB::Connection.new method.
+
+module CloudLB
+  
+  AUTH_USA = "https://auth.api.rackspacecloud.com/v1.0"
+  AUTH_UK = "https://lon.auth.api.rackspacecloud.com/v1.0"
+
+  VERSION = IO.read(File.dirname(__FILE__) + '/../VERSION').chomp
+  require 'uri'
+  require 'rubygems'
+  require 'json'
+  require 'date'
+  require 'typhoeus'
+
+  unless "".respond_to? :each_char
+    require "jcode"
+    $KCODE = 'u'
+  end
+
+  $:.unshift(File.dirname(__FILE__))
+  require 'cloudlb/exception'
+  require 'cloudlb/authentication'
+  require 'cloudlb/connection'
+  require 'cloudlb/balancer'
+  require 'cloudlb/node'
+  require 'cloudlb/health_monitor'
+  require 'cloudlb/connection_throttle'
+  
+  # Helper method to recursively symbolize hash keys.
+  def self.symbolize_keys(obj)
+    case obj
+    when Array
+      obj.inject([]){|res, val|
+        res << case val
+        when Hash, Array
+          symbolize_keys(val)
+        else
+          val
+        end
+        res
+      }
+    when Hash
+      obj.inject({}){|res, (key, val)|
+        nkey = case key
+        when String
+          key.to_sym
+        else
+          key
+        end
+        nval = case val
+        when Hash, Array
+          symbolize_keys(val)
+        else
+          val
+        end
+        res[nkey] = nval
+        res
+      }
+    else
+      obj
+    end
+  end
+  
+  def self.hydra
+    @@hydra ||= Typhoeus::Hydra.new
+  end
+  
+  # CGI.escape, but without special treatment on spaces
+  def self.escape(str,extra_exclude_chars = '')
+    str.gsub(/([^a-zA-Z0-9_.-#{extra_exclude_chars}]+)/) do
+      '%' + $1.unpack('H2' * $1.bytesize).join('%').upcase
+    end
+  end
+  
+  def self.paginate(options = {})
+    path_args = []
+    path_args.push(URI.encode("limit=#{options[:limit]}")) if options[:limit]
+    path_args.push(URI.encode("offset=#{options[:offset]}")) if options[:offset]
+    path_args.join("&")
+  end
+  
+
+end

data/lib/cloudlb/authentication.rb

@@ -0,0 +1,44 @@
+module CloudLB
+  class Authentication
+    
+    # Performs an authentication to the Rackspace Cloud authorization servers.  Opens a new HTTP connection to the API server,
+    # sends the credentials, and looks for a successful authentication.  If it succeeds, it sets the svrmgmthost,
+    # svrmgtpath, svrmgmtport, svrmgmtscheme, authtoken, and authok variables on the connection.  If it fails, it raises
+    # an exception.
+    #
+    # Should probably never be called directly.
+    def initialize(connection)
+      request = Typhoeus::Request.new(connection.auth_url,
+        :method => :get,
+        :headers => { "X-Auth-User" => connection.authuser, "X-Auth-Key" => connection.authkey },
+        :disable_ssl_peer_verification => true,
+        :verbose => ENV['LOADBALANCERS_VERBOSE'] ? true : false)
+      CloudLB.hydra.queue(request)
+      CloudLB.hydra.run
+      response = request.response
+      headers = response.headers_hash
+      if (response.code.to_s == "204")
+        connection.authtoken = headers["x-auth-token"]
+        user_id = headers["x-server-management-url"].match(/.*\/(\d+)$/)[1]
+        headers["x-server-management-url"] = case connection.region
+        when :ord
+          "https://ord.loadbalancers.api.rackspacecloud.com/v1.0/#{user_id}"
+        when :dfw
+          "https://dfw.loadbalancers.api.rackspacecloud.com/v1.0/#{user_id}"
+        else
+          raise
+        end
+        connection.lbmgmthost = URI.parse(headers["x-server-management-url"]).host
+        connection.lbmgmtpath = URI.parse(headers["x-server-management-url"]).path.chomp
+        # Force the path into the v1.0 URL space
+        connection.lbmgmtpath.sub!(/\/.*?\//, '/v1.0/')
+        connection.lbmgmtport = URI.parse(headers["x-server-management-url"]).port
+        connection.lbmgmtscheme = URI.parse(headers["x-server-management-url"]).scheme
+        connection.authok = true
+      else
+        connection.authtoken = false
+        raise CloudLB::Exception::Authentication, "Authentication failed with response code #{response.code}"
+      end
+    end
+  end
+end

data/lib/cloudlb/balancer.rb

@@ -0,0 +1,233 @@
+module CloudLB
+  class Balancer
+    
+    attr_reader :id
+    attr_reader :name
+    attr_reader :protocol
+    attr_reader :port
+    attr_reader :connection
+    attr_reader :algorithm
+    attr_reader :connection_logging
+    attr_reader :status
+    
+    # Creates a new CloudLB::Balancer object representing a Load Balancer instance.
+    def initialize(connection,id)
+      @connection    = connection
+      @id            = id
+      @lbmgmthost   = connection.lbmgmthost
+      @lbmgmtpath   = connection.lbmgmtpath
+      @lbmgmtport   = connection.lbmgmtport
+      @lbmgmtscheme = connection.lbmgmtscheme
+      populate
+      return self
+    end
+    
+    # Updates the information about the current Balancer object by making an API call.
+    def populate
+      response = @connection.lbreq("GET",@lbmgmthost,"#{@lbmgmtpath}/loadbalancers/#{CloudLB.escape(@id.to_s)}",@lbmgmtport,@lbmgmtscheme)
+      CloudLB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      data = JSON.parse(response.body)['loadBalancer']
+      @id                    = data["id"]
+      @name                  = data["name"]
+      @protocol              = data["protocol"]
+      @port                  = data["port"]
+      @algorithm             = data["algorithm"]
+      @connection_logging    = data["connectionLogging"]
+      @status                = data["status"]
+      true
+    end
+    alias :refresh :populate
+  
+    # Lists the virtual IP addresses associated with this Balancer
+    #
+    #    >> b.list_virtual_ips
+    #    => [{:type=>"PUBLIC", :address=>"174.143.139.191", :ipVersion=>"IPV4", :id=>38}]
+    def list_virtual_ips
+      response = @connection.lbreq("GET", @lbmgmthost, "#{@lbmgmtpath}/loadbalancers/#{CloudLB.escape(@id.to_s)}/virtualips",@lbmgmtport,@lbmgmtscheme)
+      CloudLB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      CloudLB.symbolize_keys(JSON.parse(response.body)["virtualIps"])
+    end
+    alias :virtual_ips :list_virtual_ips
+    
+    # Lists the backend nodes that this Balancer sends traffic to.
+    #
+    #    >> b.list_nodes
+    #    => [{:status=>"ONLINE", :port=>80, :address=>"173.203.218.1", :condition=>"ENABLED", :id=>1046}]
+    def list_nodes
+      response = @connection.lbreq("GET", @lbmgmthost, "#{@lbmgmtpath}/loadbalancers/#{CloudLB.escape(@id.to_s)}/nodes",@lbmgmtport,@lbmgmtscheme)
+      CloudLB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      CloudLB.symbolize_keys(JSON.parse(response.body)["nodes"])
+    end
+    alias :nodes :list_nodes
+    
+    # Returns a CloudLB::Node object for the given node id.
+    def get_node(id)
+      CloudLB::Node.new(self,id)
+    end
+    alias :node :get_node
+    
+    # Creates a brand new backend node and associates it with the current load balancer.  Returns the new Node object.
+    #
+    # Options include:
+    #    * :address - The IP address of the backend node *required*
+    #    * :port - The TCP port that the backend node listens on. *required*
+    #    * :condition - Can be "ENABLED" (default), "DISABLED", or "DRAINING"
+    #    * :weight - A weighting for the WEIGHTED_ balancing algorithms. Defaults to 1.
+    def create_node(options={})
+      (raise CloudLB::Exception::MissingArgument, "Must provide a node IP address") if options[:address].to_s.empty?
+      (raise CloudLB::Exception::MissingArgument, "Must provide a node TCP port") if options[:port].to_s.empty?
+      options[:condition] ||= "ENABLED"
+      body = {:nodes => [options]}.to_json
+      response = @connection.lbreq("POST", @lbmgmthost, "#{@lbmgmtpath}/loadbalancers/#{CloudLB.escape(@id.to_s)}/nodes",@lbmgmtport,@lbmgmtscheme,{},body)
+      CloudLB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      body = JSON.parse(response.body)['nodes'][0]
+      return get_node(body["id"])
+    end
+      
+    # Deletes the current load balancer object.  Returns true if successful, raises an exception otherwise.
+    def destroy!
+      response = @connection.lbreq("DELETE", @lbmgmthost, "#{@lbmgmtpath}/loadbalancers/#{CloudLB.escape(@id.to_s)}",@lbmgmtport,@lbmgmtscheme)
+      CloudLB::Exception.raise_exception(response) unless response.code.to_s.match(/^202$/)
+      true
+    end
+    
+    # TODO: Figure out formats for startTime and endTime
+    def usage
+      response = @connection.lbreq("GET",@lbmgmthost,"#{@lbmgmtpath}/loadbalancers/#{CloudLB.escape(@id.to_s)}/usage",@lbmgmtport,@lbmgmtscheme,{})
+      CloudLB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      CloudLB.symbolize_keys(JSON.parse(response.body)["loadBalancerUsageRecords"])
+    end
+    
+    # Returns either true or false if connection logging is enabled for this load balancer.
+    #
+    #    >> balancer.connection_logging?
+    #    => false
+    def connection_logging?
+      response = @connection.lbreq("GET",@lbmgmthost,"#{@lbmgmtpath}/loadbalancers/#{CloudLB.escape(@id.to_s)}/connectionlogging",@lbmgmtport,@lbmgmtscheme,{})
+      CloudLB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      JSON.parse(response.body)["connectionLogging"]["enabled"]
+    end
+    
+    # Pass either true or false in to enable or disable connection logging for this load balancer. Returns true if successful,
+    # raises execption otherwise.
+    #
+    #     >> balancer.connection_logging = true
+    #     => true
+    def connection_logging=(state)
+      (raise CloudLB::Exception::MissingArgument, "Must provide either true or false") unless [true,false].include?(state)
+      body = {'connectionLogging' => {:enabled => state}}.to_json
+      response = @connection.lbreq("PUT",@lbmgmthost,"#{@lbmgmtpath}/loadbalancers/#{CloudLB.escape(@id.to_s)}/connectionlogging",@lbmgmtport,@lbmgmtscheme,{}, body)
+      CloudLB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      true
+    end
+
+    # Sets a new name for the current load balancer.  Name must be 128 characters or less.
+    def name=(new_name="")
+      (raise CloudLB::Exception::Syntax, "Load balancer name must be 128 characters or less") if new_name.size > 128
+      (raise CloudLB::Exception::MissingArgument, "Must provide a new name") if new_name.to_s.empty?
+      body = {"name" => new_name}
+      update(body)
+    end
+    
+    # Sets a new balancer algorithm for the current load balancer. Must be a valid algorithm as returned by the
+    # CloudLB::Connection.list_algorithms call.
+    def algorithm=(new_algorithm="")
+      (raise CloudLB::Exception::MissingArgument, "Must provide a new name") if new_algorithm.to_s.empty?
+      body = {"algorithm" => new_algorithm.to_s.upcase}
+      update(body)
+    end
+    
+    # Sets a new port for the current load balancer to listen upon.
+    def port=(new_port="")
+      (raise CloudLB::Exception::MissingArgument, "Must provide a new port") if new_port.to_s.empty?
+      (raise CloudLB::Exception::Syntax, "Port must be numeric") unless new_port.to_s =~ /^\d+$/
+      body = {"port" => new_port.to_s}
+      update(body)
+    end
+    
+    # Sets a new protocol for the current load balancer to manage.  Must be a valid protocol as returned by the
+    # CloudLB::Connection.list_protocols call.
+    def protocol=(new_protocol="")
+      (raise CloudLB::Exception::MissingArgument, "Must provide a new protocol") if new_protocol.to_s.empty?
+      body = {"protocol" => new_protocol}
+      update(body)
+    end
+    
+    # Checks to see whether or not the load balancer is using HTTP cookie session persistence.  Returns true if it is, false otherwise.
+    def session_persistence?
+      response = @connection.lbreq("GET",@lbmgmthost,"#{@lbmgmtpath}/loadbalancers/#{CloudLB.escape(@id.to_s)}/sessionpersistence",@lbmgmtport,@lbmgmtscheme,{})
+      CloudLB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      JSON.parse(response.body)["sessionPersistence"]["persistenceType"] == "HTTP_COOKIE" ? true : false
+    end
+    
+    # Allows toggling of HTTP cookie session persistence.  Valid values are true and false to enable or disable, respectively.
+    # FIXME - Trying to set the persistence to true is currently returning an undocumented 405 error.
+    def session_persistence=(value)
+      (raise CloudLB::Exception::MissingArgument, "value must be true or false") unless [true,false].include?(value)
+      if value == true
+        body = {'sessionPersistence' => {'persistenceType' => 'HTTP_COOKIE'}}
+        response = @connection.lbreq("POST", @lbmgmthost, "#{@lbmgmtpath}/loadbalancers/#{CloudLB.escape(@id.to_s)}/sessionpersistence",@lbmgmtport,@lbmgmtscheme,{},body.to_json)
+      elsif value == false
+        response = @connection.lbreq("DELETE", @lbmgmthost, "#{@lbmgmtpath}/loadbalancers/#{CloudLB.escape(@id.to_s)}/sessionpersistence",@lbmgmtport,@lbmgmtscheme)
+      end
+      CloudLB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      true
+    end
+    
+    # Returns the current access control list for the load balancer.
+    def list_access_list
+      response = @connection.lbreq("GET",@lbmgmthost,"#{@lbmgmtpath}/loadbalancers/#{CloudLB.escape(@id.to_s)}/accesslist",@lbmgmtport,@lbmgmtscheme,{})
+      CloudLB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      JSON.parse(response.body)["accessList"]
+    end
+    alias :access_list :list_access_list
+    
+    # FIXME: Does not work (JSON error)
+    def add_to_access_list(options={})
+      (raise CloudLB::Exception::MissingArgument, "Must supply address and type") unless (options[:address] && options[:type])
+      body = {'networkItems' => [ { :address => options[:address], :type => options[:type].upcase}]}.to_json
+      response = @connection.lbreq("POST",@lbmgmthost,"#{@lbmgmtpath}/loadbalancers/#{CloudLB.escape(@id.to_s)}/accesslist",@lbmgmtport,@lbmgmtscheme,{},body)
+      CloudLB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      true
+    end
+    
+    # Deletes the entire access list for this load balancer, removing all entries. Returns true if successful, raises
+    # an exception otherwise.
+    #
+    #     >> balancer.delete_access_list
+    #     => true
+    def delete_access_list
+      response = @connection.lbreq("DELETE",@lbmgmthost,"#{@lbmgmtpath}/loadbalancers/#{CloudLB.escape(@id.to_s)}/accesslist",@lbmgmtport,@lbmgmtscheme,{})
+      CloudLB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      true
+    end
+    
+    # TODO
+    def delete_access_list_member(id)
+      response = @connection.lbreq("DELETE",@lbmgmthost,"#{@lbmgmtpath}/loadbalancers/#{CloudLB.escape(@id.to_s)}/accesslist/#{CloudLB.escape(id.to_s)}",@lbmgmtport,@lbmgmtscheme,{})
+      CloudLB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      true
+    end
+    
+    def get_health_monitor
+      CloudLB::HealthMonitor.new(self)
+    end
+    alias :health_monitor :get_health_monitor
+    
+    def get_connection_throttle
+      CloudLB::ConnectionThrottle.new(self)
+    end
+    alias :connection_throttle :get_connection_throttle
+    
+    private
+    
+    def update(body)
+      response = @connection.lbreq("PUT", @lbmgmthost, "#{@lbmgmtpath}/loadbalancers/#{CloudLB.escape(@id.to_s)}",@lbmgmtport,@lbmgmtscheme,{},body.to_json)
+      CloudLB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      populate
+      true
+    end
+      
+    
+  end  
+end

data/lib/cloudlb/connection.rb

@@ -0,0 +1,199 @@
+module CloudLB
+  class Connection
+    
+    attr_reader   :authuser
+    attr_reader   :authkey
+    attr_accessor :authtoken
+    attr_accessor :authok
+    attr_accessor :lbmgmthost
+    attr_accessor :lbmgmtpath
+    attr_accessor :lbmgmtport
+    attr_accessor :lbmgmtscheme
+    attr_reader   :auth_url
+    attr_reader   :region
+    
+    # Creates a new CloudLB::Connection object.  Uses CloudLB::Authentication to perform the login for the connection.
+    #
+    # Setting the retry_auth option to false will cause an exception to be thrown if your authorization token expires.
+    # Otherwise, it will attempt to reauthenticate.
+    #
+    # This will likely be the base class for most operations.
+    #
+    # The constructor takes a hash of options, including:
+    #
+    #   :username - Your Rackspace Cloud username *required*
+    #   :api_key - Your Rackspace Cloud API key *required*
+    #   :region - The region in which to manage load balancers. Current options are :dfw (Rackspace Dallas/Ft. Worth Datacenter)
+    #             and :ord (Rackspace Chicago Datacenter). *required*
+    #   :auth_url - The URL to use for authentication.  (defaults to Rackspace USA).
+    #   :retry_auth - Whether to retry if your auth token expires (defaults to true)
+    #
+    #   lb = CloudLB::Connection.new(:username => 'YOUR_USERNAME', :api_key => 'YOUR_API_KEY', :region => :dfw)
+    def initialize(options = {:retry_auth => true}) 
+      @authuser = options[:username] || (raise CloudLB::Exception::Authentication, "Must supply a :username")
+      @authkey = options[:api_key] || (raise CloudLB::Exception::Authentication, "Must supply an :api_key")
+      @region = options[:region] || (raise CloudLB::Exception::Authentication, "Must supply a :region")
+      @retry_auth = options[:retry_auth]
+      @auth_url = options[:auth_url] || CloudLB::AUTH_USA
+      @snet = ENV['RACKSPACE_SERVICENET'] || options[:snet]
+      @authok = false
+      @http = {}
+      CloudLB::Authentication.new(self)
+    end
+    
+    # Returns true if the authentication was successful and returns false otherwise.
+    #
+    #   lb.authok?
+    #   => true
+    def authok?
+      @authok
+    end
+    
+    # Returns the list of available load balancers.  By default, it hides deleted load balancers (which hang around unusable
+    # for 90 days). To show all load balancers, including deleted ones, pass in :show_deleted => true.
+    #
+    # Information returned includes:
+    #   * :id - The numeric ID of this load balancer
+    #   * :name - The name of the load balancer
+    #   * :status - The current state of the load balancer (ACTIVE, BUILD, PENDING_UPDATE, PENDING_DELETE, SUSPENDED, ERROR)
+    #   * :port - The TCP port that the load balancer listens on
+    #   * :protocol - The network protocol being balanced.
+    #   * :algorithm - The balancing algorithm used by this load balancer
+    #   * :created[:time] - The time that the load balancer was created
+    #   * :updated[:time] - The most recent time that the load balancer was modified
+    #   * :virutalIps - Information about the Virtual IPs providing service to this load balancer.
+    def list_load_balancers(options={})
+      response = lbreq("GET",lbmgmthost,"#{lbmgmtpath}/loadbalancers",lbmgmtport,lbmgmtscheme)
+      CloudLB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      balancers = CloudLB.symbolize_keys(JSON.parse(response.body)["loadBalancers"])
+      return options[:show_deleted] == true ? balancers : balancers.select{|lb| lb[:status] != "DELETED"}
+    end
+    alias :load_balancers :list_load_balancers
+    
+    # Returns a CloudLB::Balancer object for the given load balancer ID number.
+    #
+    #    >> lb.get_load_balancer(2)
+    def get_load_balancer(id)
+      CloudLB::Balancer.new(self,id)
+    end
+    alias :load_balancer :get_load_balancer
+    
+    # Creates a brand new load balancer under your account.
+    #
+    # A minimal request must pass in :name, :protocol, :nodes, and either :virtual_ip_ids or :virtual_ip_types.
+    #
+    # Options:
+    # :name - the name of the load balancer.  Limted to 128 characters or less.
+    # :protocol - the protocol to balance. Must be a valid protocol. Get the list of available protocols with the list_protocols
+    #             command. Supported in the latest docs are: HTTP, HTTPS, FTP, IMAPv4, IMAPS, POP3, POP3S, LDAP, LDAPS, SMTP
+    # :nodes - An array of hashes for each node to be balanced.  The hash should contain the address of the target server, 
+    #          the port on the target server, and the condition ("ENABLED", "DISABLED", "DRAINING"). Optionally supply a :weight for use
+    #          in the WEIGHTED_ algorithms.
+    #          {:address => "1.2.3.4", :port => "80", :condition => "ENABLED", :weight => 1}
+    # :port - the port that the load balancer listens on. Defaults to the standard port for the protocol.
+    # :algorithm - A valid balancing algorithm.  Use the algorithms method to get the list. Valid in the current documentation
+    #              are RANDOM (default), LEAST_CONNECTIONS, ROUND_ROBIN, WEIGHTED_LEAST_CONNECTIONS, WEIGHTED_ROUND_ROBIN
+    # :virtual_ip_id -  If you have existing virtual IPs and would like to reuse them in a different balancer (for example, to
+    #                   load balance both HTTP and HTTPS on the same IP), you can pass in an array of the ID numbers for those
+    #                   virtual IPs
+    # :virtual_ip_type - Alternately, you can get new IP addresses by passing in the type of addresses that you
+    #                     want to obtain.  Values are "PUBLIC" or "PRIVATE".
+    def create_load_balancer(options = {})
+      body = Hash.new
+      body[:name] = options[:name] or raise CloudLB::Exception::MissingArgument, "Must provide a name to create a load balancer"
+      (raise CloudLB::Exception::Syntax, "Load balancer name must be 128 characters or less") if options[:name].size > 128
+      (raise CloudLB::Exception::Syntax, "Must provide at least one node in the :nodes array") if (!options[:nodes].is_a?(Array) || options[:nodes].size < 1)
+      body[:protocol] = options[:protocol] or raise CloudLB::Exception::MissingArgument, "Must provide a protocol to create a load balancer"
+      body[:port] = options[:port] if options[:port]
+      body[:nodes] = options[:nodes]
+      body[:protocol].upcase! if body[:protocol]
+      body[:algorithm].upcase! if body[:algorithm]
+      if options[:virtual_ip_id]
+        body['virtualIps'] = [{:id => options[:virtual_ip_id]}]
+      elsif options[:virtual_ip_type]
+        body['virtualIps'] = [{:type => options[:virtual_ip_type]}]
+      end
+      response = lbreq("POST",lbmgmthost,"#{lbmgmtpath}/loadbalancers",lbmgmtport,lbmgmtscheme,{},body.to_json)
+      CloudLB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      body = JSON.parse(response.body)['loadBalancer']
+      return get_load_balancer(body["id"])
+    end
+    
+    # Returns a list of protocols that are currently supported by the Cloud Load Balancer product.
+    #
+    #   >> lb.list_protocols
+    #   => [{:port=>21, :name=>"FTP"}, {:port=>80, :name=>"HTTP"}, {:port=>443, :name=>"HTTPS"}, {:port=>993, :name=>"IMAPS"}, {:port=>143, :name=>"IMAPv4"}, {:port=>389, :name=>"LDAP"}, {:port=>636, :name=>"LDAPS"}, {:port=>110, :name=>"POP3"}, {:port=>995, :name=>"POP3S"}, {:port=>25, :name=>"SMTP"}]
+    def list_protocols
+      response = lbreq("GET",lbmgmthost,"#{lbmgmtpath}/loadbalancers/protocols",lbmgmtport,lbmgmtscheme,{})
+      CloudLB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      CloudLB.symbolize_keys(JSON.parse(response.body)["protocols"])    
+    end
+    alias :protocols :list_protocols
+    
+    # Returns a list of balancer algorithms that are currently supported by the Cloud Load Balancer product.
+    #
+    #   >> lb.list_algorithms
+    #   => [{:name=>"LEAST_CONNECTIONS"}, {:name=>"RANDOM"}, {:name=>"ROUND_ROBIN"}, {:name=>"WEIGHTED_LEAST_CONNECTIONS"}, {:name=>"WEIGHTED_ROUND_ROBIN"}]
+    def list_algorithms
+      response = lbreq("GET",lbmgmthost,"#{lbmgmtpath}/loadbalancers/algorithms",lbmgmtport,lbmgmtscheme,{})
+      CloudLB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      CloudLB.symbolize_keys(JSON.parse(response.body)["algorithms"])    
+    end      
+    alias :algorithms :list_algorithms
+    
+    
+    # This method actually makes the HTTP REST calls out to the server. Relies on the thread-safe typhoeus
+    # gem to do the heavy lifting.  Never called directly.
+    def lbreq(method,server,path,port,scheme,headers = {},data = nil,attempts = 0) # :nodoc:
+      if data
+        unless data.is_a?(IO)
+          headers['Content-Length'] = data.respond_to?(:lstat) ? data.stat.size : data.size
+        end
+      else
+        headers['Content-Length'] = 0
+      end
+      hdrhash = headerprep(headers)
+      url = "#{scheme}://#{server}#{path}"
+      print "DEBUG: Data is #{data}\n" if (data && ENV['LOADBALANCERS_VERBOSE'])
+      request = Typhoeus::Request.new(url,
+                                      :body          => data,
+                                      :method        => method.downcase.to_sym,
+                                      :headers       => hdrhash,
+                                      # :user_agent    => "CloudLB Ruby API #{VERSION}",
+                                      :verbose       => ENV['LOADBALANCERS_VERBOSE'] ? true : false)
+      CloudLB.hydra.queue(request)
+      CloudLB.hydra.run
+      
+      response = request.response
+      print "DEBUG: Body is #{response.body}\n" if ENV['LOADBALANCERS_VERBOSE']
+      raise CloudLB::Exception::ExpiredAuthToken if response.code.to_s == "401"
+      response
+    rescue Errno::EPIPE, Errno::EINVAL, EOFError
+      # Server closed the connection, retry
+      raise CloudLB::Exception::Connection, "Unable to reconnect to #{server} after #{attempts} attempts" if attempts >= 5
+      attempts += 1
+      @http[server].finish if @http[server].started?
+      start_http(server,path,port,scheme,headers)
+      retry
+    rescue CloudLB::Exception::ExpiredAuthToken
+      raise CloudLB::Exception::Connection, "Authentication token expired and you have requested not to retry" if @retry_auth == false
+      CloudLB::Authentication.new(self)
+      retry
+    end
+    
+    
+    private
+    
+    # Sets up standard HTTP headers
+    def headerprep(headers = {}) # :nodoc:
+      default_headers = {}
+      default_headers["X-Auth-Token"] = @authtoken if (authok? && @account.nil?)
+      default_headers["X-Storage-Token"] = @authtoken if (authok? && !@account.nil?)
+      default_headers["Connection"] = "Keep-Alive"
+      default_headers["Accept"] = "application/json"
+      default_headers["Content-Type"] = "application/json"
+      default_headers.merge(headers)
+    end    
+        
+  end
+end

data/lib/cloudlb/connection_throttle.rb

@@ -0,0 +1,105 @@
+module CloudLB
+  class ConnectionThrottle
+  
+    attr_reader :min_connections
+    attr_reader :max_connections
+    attr_reader :max_connection_rate
+    attr_reader :rate_interval
+    
+    # Initializes a new CloudLB::ConnectionThrottle object with the current values. If there is no connection 
+    # throttle currently defined, the enabled? method returns false.
+    def initialize(load_balancer)
+      @connection    = load_balancer.connection
+      @load_balancer = load_balancer
+      @lbmgmthost   = @connection.lbmgmthost
+      @lbmgmtpath   = @connection.lbmgmtpath
+      @lbmgmtport   = @connection.lbmgmtport
+      @lbmgmtscheme = @connection.lbmgmtscheme
+      populate
+      return self
+    end
+  
+    def populate
+      response = @connection.lbreq("GET",@lbmgmthost,"#{@lbmgmtpath}/loadbalancers/#{CloudLB.escape(@load_balancer.id.to_s)}/connectionthrottle",@lbmgmtport,@lbmgmtscheme)
+      CloudLB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      data = JSON.parse(response.body)['connectionThrottle']
+      @enabled = data == {} ? false : true
+      return nil unless @enabled
+      @min_connections = data["minConnections"]
+      @max_connections = data["maxConnections"]
+      @max_connection_rate = data["maxConnectionRate"]
+      @rate_interval = data["rateInterval"]
+      true
+    end
+    alias :refresh :populate
+  
+    # Returns true if the connection throttle is defined and has data, returns false if not.
+    def enabled?
+      @enabled
+    end
+    
+    # Updates (or creates) the connection throttle with the supplied arguments
+    # 
+    # To create a health monitor for the first time, you must supply all *required* options. However, to modify an 
+    # existing monitor, you need only supply the the value that you want to change.
+    #
+    # Options include:
+    #
+    #   * :max_connections - Maximum number of connection to allow for a single IP address. *required*
+    #   * :min_connections - Allow at least this number of connections per IP address before applying throttling restrictions. *required*
+    #   * :max_connection_rate - Maximum number of connections allowed from a single IP address in the defined :rate_interval. *required*
+    #   * :rate_interval - Frequency (in seconds) at which the maxConnectionRate is assessed. For example, a :max_connection_rate of 30 
+    #                      with a :rate_interval of 60 would allow a maximum of 30 connections per minute for a single IP address. *required*
+    def update(options={})
+      data = Hash.new
+      data['maxConnections'] = options[:max_connections] if options[:max_connections]
+      data['minConnections'] = options[:min_connections] if options[:min_connections]
+      data['maxConnectionRate'] = options[:max_connection_rate] if options[:max_connection_rate]
+      data['rateInterval'] = options[:rate_interval] if options[:rate_interval]
+      
+      response = @connection.lbreq("PUT",@lbmgmthost,"#{@lbmgmtpath}/loadbalancers/#{CloudLB.escape(@load_balancer.id.to_s)}/connectionthrottle",@lbmgmtport,@lbmgmtscheme,{},data.to_json)
+      CloudLB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      populate
+      true
+    end
+    
+    # Convenience method to update the max_connections value. Returns false if the connection throttle is not enabled,
+    # the new value if it succeeds, and raises an exception otherwise.
+    def max_connections=(value)
+      return false unless @enabled
+      update(:max_connections => value)
+    end
+    
+    # Convenience method to update the min_connections value. Returns false if the connection throttle is not enabled,
+    # the new value if it succeeds, and raises an exception otherwise.
+    def min_connections=(value)
+      return false unless @enabled
+      update(:min_connections => value)
+    end
+    
+    # Convenience method to update the max_connection_rate value. Returns false if the connection throttle is not enabled,
+    # the new value if it succeeds, and raises an exception otherwise.
+    def max_connection_rate=(value)
+      return false unless @enabled
+      update(:max_connection_rate => value)
+    end
+    
+    # Convenience method to update the rate_interval value. Returns false if the connection throttle is not enabled,
+    # the new value if it succeeds, and raises an exception otherwise.
+    def rate_interval=(value)
+      return false unless @enabled
+      update(:rate_interval => value)
+    end
+    
+    # Removes the current health monitor.  Returns true if successful, exception otherwise.
+    #
+    #     >> monitor.destroy!
+    #     => true
+    def destroy!
+      response = @connection.lbreq("DELETE",@lbmgmthost,"#{@lbmgmtpath}/loadbalancers/#{CloudLB.escape(@load_balancer.id.to_s)}/connectionthrottle",@lbmgmtport,@lbmgmtscheme)
+      CloudLB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      @enabled = false
+      true
+    end
+  end
+end

data/lib/cloudlb/exception.rb

@@ -0,0 +1,65 @@
+module CloudLB
+  class Exception
+
+    class CloudLBError < StandardError
+
+      attr_reader :response_body
+      attr_reader :response_code
+
+      def initialize(message, code, response_body)
+        @response_code=code
+        @response_body=response_body
+        super(message)
+      end
+
+    end
+    
+    class LoadBalancerFault           < CloudLBError # :nodoc:
+    end
+    class ServiceUnavailable          < CloudLBError # :nodoc:
+    end
+    class Unauthorized                < CloudLBError # :nodoc:
+    end
+    class BadRequest                  < CloudLBError # :nodoc:
+    end
+    class OverLimit                   < CloudLBError # :nodoc:
+    end
+    class Other                       < CloudLBError # :nodoc:
+    end
+    
+    # Plus some others that we define here
+    
+    class ExpiredAuthToken            < StandardError # :nodoc:
+    end
+    class MissingArgument             < StandardError # :nodoc:
+    end
+    class Authentication              < StandardError # :nodoc:
+    end
+    class Connection                  < StandardError # :nodoc:
+    end
+    class Syntax                      < StandardError # :nodoc:
+    end
+    
+        
+    # In the event of a non-200 HTTP status code, this method takes the HTTP response, parses
+    # the JSON from the body to get more information about the exception, then raises the
+    # proper error.  Note that all exceptions are scoped in the CloudLB::Exception namespace.
+    def self.raise_exception(response)
+      return if response.code =~ /^20.$/
+      begin
+        fault = nil
+        info = nil
+        JSON.parse(response.body).each_pair do |key, val|
+			    fault=key
+			    info=val
+			  end
+        exception_class = self.const_get(fault[0,1].capitalize+fault[1,fault.length])
+        raise exception_class.new(info["message"], response.code, response.body)
+      rescue NameError, JSON::ParserError
+        raise CloudLB::Exception::Other.new("The server returned status #{response.code} with body #{response.body}", response.code, response.body)
+      end
+    end
+    
+  end
+end
+

data/lib/cloudlb/health_monitor.rb

@@ -0,0 +1,135 @@
+module CloudLB
+  class HealthMonitor
+  
+    attr_reader :type
+    attr_reader :delay
+    attr_reader :timeout
+    attr_reader :attempts_before_deactivation
+    attr_reader :path
+    attr_reader :status_regex
+    attr_reader :body_regex
+    
+    # Initializes a new CloudLB::ConnectionThrottle object
+    def initialize(load_balancer)
+      @connection    = load_balancer.connection
+      @load_balancer = load_balancer
+      @lbmgmthost   = @connection.lbmgmthost
+      @lbmgmtpath   = @connection.lbmgmtpath
+      @lbmgmtport   = @connection.lbmgmtport
+      @lbmgmtscheme = @connection.lbmgmtscheme
+      populate
+      return self
+    end
+  
+    def populate
+      response = @connection.lbreq("GET",@lbmgmthost,"#{@lbmgmtpath}/loadbalancers/#{CloudLB.escape(@load_balancer.id.to_s)}/healthmonitor",@lbmgmtport,@lbmgmtscheme)
+      CloudLB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      data = JSON.parse(response.body)['healthMonitor']
+      @enabled = data == {} ? false : true
+      return nil unless @enabled
+      @type = data["type"]
+      @delay = data["delay"]
+      @timeout = data["timeout"]
+      @attempts_before_deactivation = data["attemptsBeforeDeactivation"]
+      @path = data["path"]
+      @status_regex = data["statusRegex"]
+      @body_regex = data["bodyRegex"]
+      true
+    end
+    alias :refresh :populate
+  
+    # Returns true if the health monitor is defined and has data, returns false if not.
+    def enabled?
+      @enabled
+    end
+    
+    # Updates (or creates) the health monitor with the supplied arguments
+    # 
+    # To create a health monitor for the first time, you must supply all *required* options. However, to modify an 
+    # existing monitor, you need only supply the :type and whatever it is that you want to change.
+    #
+    # Options include:
+    #
+    #   * :type - The type of health monitor. Can be CONNECT (simple TCP connections), HTTP, or HTTPS. The HTTP and HTTPS
+    #             monitors require additional options. *required*
+    #   * :delay - The minimum number of seconds to wait before executing the health monitor. *required*
+    #   * :timeout - Maximum number of seconds to wait for a connection to be established before timing out. *required*
+    #   * :attempts_before_deactivation - Number of permissible monitor failures before removing a node from rotation. *required*
+    #
+    # For HTTP and HTTPS monitors, there are additional options. You must supply the :path and either the :status_regex or :body_regex
+    #
+    #   * :path - The HTTP path that will be used in the sample request. *required*
+    #   * :status_regex - A regular expression that will be used to evaluate the HTTP status code returned in the response 
+    #   * :body_regex - A regular expression that will be used to evaluate the contents of the body of the response.
+    def update(options={})
+      data = Hash.new
+      data[:type] = options[:type].upcase if options[:type]
+      data[:delay] = options[:delay] if options[:delay]
+      data[:timeout] = options[:timeout] if options[:timeout]
+      data['attemptsBeforeDeactivation'] = options[:attempts_before_deactivation] if options[:attempts_before_deactivation]
+      data[:type].upcase! if data[:type]
+      if ['HTTP','HTTPS'].include?(data[:type])
+        data[:path] = options[:path] if options[:path]
+        data['statusRegex'] = options[:status_regex] if options[:status_regex]
+        data['bodyRegex'] = options[:body_regex] if options[:body_regex]
+      end
+      response = @connection.lbreq("PUT",@lbmgmthost,"#{@lbmgmtpath}/loadbalancers/#{CloudLB.escape(@load_balancer.id.to_s)}/healthmonitor",@lbmgmtport,@lbmgmtscheme,{},data.to_json)
+      CloudLB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      populate
+      true
+    end
+    
+    # Convenience method to update the delay value for the current type. Returns false if the health monitor is not enabled,
+    # the new value if it succeeds, and raises an exception otherwise.
+    def delay=(value)
+      return false unless @enabled
+      update(:type => self.type, :delay => value)
+    end
+    
+    # Convenience method to update the timeout value for the current type. Returns false if the health monitor is not enabled,
+    # the new value if it succeeds, and raises an exception otherwise.
+    def timeout=(value)
+      return false unless @enabled
+      update(:type => self.type, :timeout => value)
+    end
+    
+    # Convenience method to update the attempts before deactivation value for the current type. Returns false if the health monitor is not enabled,
+    # the new value if it succeeds, and raises an exception otherwise.
+    def attempts_before_deactivation=(value)
+      return false unless @enabled
+      update(:type => self.type, :attempts_before_deactivation => value)
+    end
+    
+    # Convenience method to update the path value for the current type. Returns false if the health monitor is not enabled
+    # or not an http monitor, the new value if it succeeds, and raises an exception otherwise.
+    def path=(value)
+      return false unless @enabled && ['HTTP','HTTPS'].include?(self.type)
+      update(:type => self.type, :path => value)
+    end
+    
+    # Convenience method to update the delay value for the current type. Returns false if the health monitor is not enabled
+    # or is not an http monitor, the new value if it succeeds, and raises an exception otherwise.
+    def status_regex=(value)
+      return false unless @enabled && ['HTTP','HTTPS'].include?(self.type)
+      update(:type => self.type, :status_regex => value)
+    end
+    
+    # Convenience method to update the delay value for the current type. Returns false if the health monitor is not enabled
+    # or is not an http monitor, the new value if it succeeds, and raises an exception otherwise.
+    def body_regex=(value)
+      return false unless @enabled && ['HTTP','HTTPS'].include?(self.type)
+      update(:type => self.type, :body_regex => value)
+    end
+    
+    # Removes the current health monitor.  Returns true if successful, exception otherwise.
+    #
+    #     >> monitor.destroy!
+    #     => true
+    def destroy!
+      response = @connection.lbreq("DELETE",@lbmgmthost,"#{@lbmgmtpath}/loadbalancers/#{CloudLB.escape(@load_balancer.id.to_s)}/healthmonitor",@lbmgmtport,@lbmgmtscheme)
+      CloudLB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      @enabled = false
+      true
+    end
+  end
+end

data/lib/cloudlb/node.rb

@@ -0,0 +1,64 @@
+module CloudLB
+  class Node
+    
+    attr_reader :id
+    attr_reader :address
+    attr_reader :condition
+    attr_reader :port
+    attr_reader :weight
+    attr_reader :status
+    
+    # Initializes a new CloudLB::Node object
+    def initialize(load_balancer,id)
+      @connection    = load_balancer.connection
+      @load_balancer = load_balancer
+      @id            = id
+      @lbmgmthost   = @connection.lbmgmthost
+      @lbmgmtpath   = @connection.lbmgmtpath
+      @lbmgmtport   = @connection.lbmgmtport
+      @lbmgmtscheme = @connection.lbmgmtscheme
+      populate
+      return self
+    end
+    
+    # Updates the information about this CloudLB::Node object by making an API call.
+    def populate
+      response = @connection.lbreq("GET",@lbmgmthost,"#{@lbmgmtpath}/loadbalancers/#{CloudLB.escape(@load_balancer.id.to_s)}/nodes/#{CloudLB.escape(@id.to_s)}",@lbmgmtport,@lbmgmtscheme)
+      CloudLB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      data = JSON.parse(response.body)['node']
+      @id                    = data["id"]
+      @address                  = data["address"]
+      @condition              = data["condition"]
+      @port                  = data["port"]
+      @weight             = data["weight"]
+      @status                = data["status"]
+      true
+    end
+    alias :refresh :populate
+    
+    # Allows you to change the condition of the current Node. Values should be either "ENABLED", "DISABLED", or "DRAINING"
+    def condition=(data)
+      (raise CloudLB::Exception::MissingArgument, "Must provide a new node condition") if data.to_s.empty?
+      body = {"condition" => data.to_s.upcase}
+      update(body)
+    end
+    
+    # Deletes the current Node object and removes it from the load balancer. Returns true if successful, raises an exception if not.
+    def destroy!
+      response = @connection.lbreq("DELETE",@lbmgmthost,"#{@lbmgmtpath}/loadbalancers/#{CloudLB.escape(@load_balancer.id.to_s)}/nodes/#{CloudLB.escape(@id.to_s)}",@lbmgmtport,@lbmgmtscheme)
+      CloudLB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      true
+    end
+    
+    private
+    
+    def update(data)
+      body = {:node => data}
+      response = @connection.lbreq("PUT", @lbmgmthost, "#{@lbmgmtpath}/loadbalancers/#{CloudLB.escape(@load_balancer.id.to_s)}/nodes/#{CloudLB.escape(@id.to_s)}",@lbmgmtport,@lbmgmtscheme,{},body.to_json)
+      CloudLB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)
+      populate
+      true
+    end
+    
+  end
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification 
+name: cloudlb
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- H. Wade Minter
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-25 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: typhoeus
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+description: A Ruby API to manage the Rackspace Cloud Load Balancers product
+email: 
+- minter@lunenburg.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- VERSION
+- COPYING
+- .gitignore
+- README.rdoc
+- cloudlb.gemspec
+- lib/cloudlb.rb
+- lib/cloudlb/authentication.rb
+- lib/cloudlb/balancer.rb
+- lib/cloudlb/connection.rb
+- lib/cloudlb/exception.rb
+- lib/cloudlb/node.rb
+- lib/cloudlb/health_monitor.rb
+- lib/cloudlb/connection_throttle.rb
+has_rdoc: true
+homepage: http://github.com/rackspace/ruby-cloudlb
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: Ruby API into the Rackspace Cloud Load Balancers product
+test_files: []
+