jamesn-softlayer-ruby 0.6.3.0 → 0.7.0.0

data/Changes

@@ -1,4 +1,14 @@
 
+Changes since 0.6.3
+
+
+Added a CDNLayer sample
+Refactor slapiCall and realCall to clean up a bit of a mess, fix method parameter handling, and cleans up header handling. There's a bit of an api change here.
+Clean up initParamater handling (so that it actually works again)
+Allow the base class to be replaced with another.
+Split softlayer.rb into three files, one containing just the base class, another containing 
+the header and exception classes.
+
 Change since 0.6.1
 
 Silenced the name space warning (I think this is a bug in soap4r)

data/lib/softlayer.rb

@@ -37,16 +37,23 @@ gem 'soap4r'
 require 'soap/header/simplehandler'
 require 'soap/wsdlDriver'
 
+require 'softlayer/baseclass'
+require 'softlayer/util'
+
 
 module SoftLayer
 
+  DEFAULTBASE=SoftLayer::BaseClass
+
   # Declare SLAPI clases.  Args take class names in two forms:
   # +soap+:: Service names in SOAP format (example: SoftLayer_Account)
   # +ruby+:: Class names in Ruby format (example:  SoftLayer::Account)
+  # +base+:: A substitute base class (otherwise SoftLayer::Base)
   # Creates the class, and retrieves and caches the endpoint WSDL.
   def SoftLayer::declareClasses(args)
     classes = args[:ruby]
     services = args[:soap]
+    base = args[:base]
 
     unless (services.nil? || services.empty?)
       services.each do |s|
@@ -56,7 +63,7 @@ module SoftLayer
     end
 
     classes.each do |cstr|
-      k = SoftLayer::ClassFactory(:class => cstr)
+      k = SoftLayer::ClassFactory(:class => cstr, :base => base)
       k.cacheWSDL
     end
   end
@@ -65,338 +72,42 @@ module SoftLayer
   # Args:
   # +class+:: The name of the class to create in Ruby format.
   # +parent+:: The parent namespace to add the class to (this should be somewere in SoftLayer; optional).
+  # +base+:: A substitute base class (otherwise SoftLayer::Base)
   # This recursively walks up +class+ creating them as needed, so SoftLayer::Dns::Domain will create
   # classes for Dns and Domain (even though the Dns class will never be used).
   def SoftLayer::ClassFactory(args)
     cname = args[:class]
     parent = args[:parent] unless args[:parent].nil?
+    base = args[:base]
+    base = DEFAULTBASE if base.nil?
 
     cary = cname.split('::')
     parent = const_get(cary.shift) if parent.nil? # This should always be SoftLayer, but maybe not...
     cur = cary.shift
     newclass = nil
     unless parent.const_defined?(cur)
-      newclass = SoftLayer::makeSLAPIKlass(:class => cur, :parent => parent)
+      newclass = SoftLayer::makeSLAPIKlass(:class => cur, :parent => parent, :base => base)
     else
       newclass = parent.const_get(cur)
     end
     return newclass if cary.empty?
 
     left = cary.join('::')
-    k = SoftLayer::ClassFactory(:class => left, :parent => newclass) 
+    k = SoftLayer::ClassFactory(:class => left, :parent => newclass, :base => base) 
     return k
   end
 
   # This really creates the class.
   # +class+:: The name of the class to create in Ruby format.
   # +parent+:: The parent namespace to add the class to (this should be somewhere in SoftLayer, not optional).
+  # +base+:: A substitute base class (otherwise SoftLayer::Base)
   def SoftLayer::makeSLAPIKlass(args)
     cname = args[:class]
     parent = args[:parent]
+    base = args[:base]
     realKlassName = "#{cname}"
-    klass = Class.new SoftLayer::BaseClass do 
-
-    end
+    klass = Class.new base do ; end
     parent.const_set realKlassName, klass
     return klass
   end
-
-  # A class to old Paramaters.
-  class Param < SOAP::Header::SimpleHandler
-    def initialize(tag, out)
-      @out = out
-      super(XSD::QName.new(nil, tag))
-    end
-
-    def on_simple_outbound
-      @out
-    end
-
-    def [](k)
-      return @out[k]
-    end
-
-    def []=(k,v)
-      @out[k]=v
-    end
-  end
-
-  # A class to hold the object mask.
-  class ObjectMask < SOAP::Header::SimpleHandler
-
-    def initialize(tag, out)
-      @out = out
-      super(XSD::QName.new(nil, tag))
-    end
-
-    def on_simple_outbound
-      { 'mask' => @out }
-    end
-
-    def [](k)
-      @out[k]
-    end
-
-    def []=(k,v)
-      @out[k]=v
-    end
-  end
-
-  class ResultLimit < SOAP::Header::SimpleHandler
-    attr_accessor :limit, :offset
-
-    # limit should be an array of two elements; limit and offset.
-    def initialize(tag, limit)
-      @limit = limit[0]
-      @offset = limit[1]
-      super(XSD::QName.new(nil, tag))
-    end
-
-    def on_simple_outbound
-      { 'limit' => @limit, 'offset' => @offset }
-    end
-  end
-
-
-  # An Exception proxy class
-  # This doesn't do anything yet, but it probably
-  # will at some point.
-  class Exception < RuntimeError
-
-    def initialize(args)
-      e = args[:exception]
-      message = args[:message] unless args[:message].nil?
-      message = e.message unless e.nil?
-      super(message)
-      
-      @realException = e unless e.nil?
-      @realException = self if @realException.nil?
-    end
-  end
-
-  # The Base class for our generated class.
-  class BaseClass
-
-    WSDLBASE='http://api.service.softlayer.com/soap/v3'
-    WSDLPARAM='?wsdl'
-
-    @@wsdl = { }
-    @@apiUser = nil
-    @@apiKey = nil
-
-    # The initializer.
-    # Arguments:
-    # +user+::  The API User
-    # +key+:: The API Key
-    # +initParams+:: This object's initParam (just the key)
-    # +debug+:: Enable debug after driver creation. (IO handler)
-    #
-    # +user+ and +key+ are optional.  The first time they're presented
-    # they're saved to class variables and reused later as necessary.  Supplying
-    # +user+ and +key+ later does not overwrite the class variables.  +initParams+ is
-    # required where the api requires it.
-    def initialize(args)
-      @apiUser = args[:user] unless args[:user].nil?
-      @apiKey = args[:key] unless args[:key].nil?
-      @initParam = args[:initParam]
-
-      @@apiUser = args[:user] unless (args[:user].nil? || !@@apiUser.nil?)
-      @@apiKey = args[:key] unless (args[:key].nil? || !@@apiKey.nil?)
-      @apiUser = @@apiUser unless (@@apiUser.nil? || !@apiUser.nil?)
-      @apiKey = @@apiKey unless (@@apiKey.nil? || !@apiKey.nil?)
-      @authHeader = Param.new('authenticate', {'username' => @apiUser, 'apiKey' => @apiKey})
-
-      self.class.cacheWSDL
-      @slapi = @@wsdl[self.soapClass].create_rpc_driver unless @@wsdl[self.soapClass].nil?
-      raise SoftLayer::Exception.new(:message => 'WSDL endpoint not available.') if @slapi.nil?
-      
-      self.debug=args[:debug] unless args[:debug].nil?
-    end
-
-    # Return this object's matching SLAPI SOAP Class.
-    def soapClass
-      return self.class.to_s.gsub(/::/, '_')
-    end
-
-    # This returns key values from this Service's associated Type (retrieved using #getObject).
-    def [](key)
-      @slapiObject = self.getObject if @slapiobject.nil?
-      return @slapiObject[key.to_s]
-    end
-
-    def setObject(obj)
-      @slapiObject = obj
-    end
-
-    # Set the object mask which ia passed as a hash of optional hashes (otherwise the hash elements should have a nil value).
-    # Using the example from the wiki:
-    #  <SoftLayer_AccountObjectMask xsi:type="v3:SoftLayer_AccountObjectMask">
-    #    <mask xsi:type="slt:SoftLayer_Account" xmlns:slt="http://api.service.softlayer.com/soap/v3/SLTypes/">
-    #        <domains>
-    #            <resourceRecords />
-    #        </domains>
-    #        <openTickets>
-    #            <assignedUser />
-    #            <attachedHardware />
-    #            <updates />
-    #        </openTickets>
-    #        <userCount />
-    #    </mask>
-    #  </SoftLayer_AccountObjectMask>
-    #
-    #  { 'domains' => { 'resourceRecords' => nil }, 'openTicket' => { 'assignedUser' => nil, 'attachedHardware' => nil, 'updates' => nil },
-    #   userCount => nil }
-    # Changing this resets the cached object used by #[]
-    def objectMask=(mask)
-      if mask.class == ObjectMask
-        @objectMask = mask
-      else
-        @objectMask = ObjectMask.new("#{self.soapClass}ObjectMask", mask)
-      end
-      @slapiObject = nil
-    end
-
-    def objectMask
-      return @objectMask
-    end
-
-    # Set an object wide result set (or clear it)
-    # arg can be one of three things:
-    # * nil clears the resultLimit
-    # * A Result Limit array of two elements range and offset.
-    # * An existing ResultLimit object
-    def resultLimit=(arg)
-      case arg.class
-      when NilClass
-        @resultLimit = nil
-      when Array
-        @resultLimit = ResultLimit.new('resultLimit',arg)
-      when ResultLimit
-        @resultLimit = arg
-      end
-    end
-
-    def resultLimit
-      return @resultLimit
-    end
-
-
-    # Make a direct api call.  Paramaters are a hash where the key is passed to ParamHeader as the tag, and the value
-    # is passed as the tag content, unless it's a magic paramater.
-    # Magic Paramaters:
-    # +initParam+:: Initialization paramater for this call (just the key), therwise @initParam is used.
-    # +limit+:: A Result Limit array of two elements range and offset.  If @resultLimit is set it's used
-    # if +limit+ is not and if neither is set, no limit is applied.
-    # 
-    # If a block is provided, the limit's range (or fewer) elements will yield to the block until the dataset
-    # is exhausted.  If no limit is provided with the block a limit of [1,0] is assumed initially.
-    # Aliased to #method_missing.
-    def slapiCall(method, args = { }, &block)
-
-      initParam = args[:initParam] unless args[:initParam].nil?
-      args.delete(:initParam) unless args[:initParam].nil?
-      initParam = Param.new("#{self.soapClass}InitParameters", { 'id' => initParam }) unless initParam.nil?
-      initParam = @initParam if initParam.nil?
-      resultLimit = ResultLimit.new('resultLimit', args[:limit]) unless args[:limit].nil?
-      args.delete(:limit) unless args[:limit].nil?
-      resultLimit = @resultLimit if resultLimit.nil?
-
-      @slapi.headerhandler << @authHeader unless @slapi.headerhandler.include?(@authHeader)
-      paramHeaders = []
-      unless args.nil?
-        args.each do |k,v|
-          p = Param.new(k.to_s,v)
-          paramHeaders.push(p)
-          @slapi.headerhandler << p
-        end
-      end
-      @slapi.headerhandler << initParam unless @slapi.headerhandler.include?(@authHeader)
-      @slapi.headerhandler << @objectMask unless @objectMask.nil?
-      @slapi.headerhandler << resultLimit unless resultLimit.nil?
-
-      if block_given?
-        go=true
-        resultLimit = ResultLimit.new('resultLimit', [1,0]) if resultLimit.nil? # this is broken.
-        @slapi.headerhandler << resultLimit unless @slapi.headerhandler.include?(resultLimit)
-        while(go) do
-          res = realCall(method.to_s)
-          yield(res) unless (res.nil? || (res.respond_to?(:empty) && res.empty?))
-          go = false if res.nil?
-          go = false if (res.respond_to?(:size) && (res.size < resultLimit.limit))
-          resultLimit.offset=resultLimit.offset + resultLimit.limit
-        end
-        headerClean(resultLimit,paramHeaders)
-        return true
-      else
-        res = realCall(method.to_s)
-        headerClean(resultLimit,paramHeaders)
-        return res
-      end
-    end
-
-    # Alias the above slapiCall to #method_missing.
-    alias_method  :method_missing, :slapiCall
-    # Alias slapiCall to #call specifically because of it's special paramter list.
-    alias_method :call, :slapiCall
-
-    # Enable (or disable) debug. (paramater is the IO handler to write to)
-    def debug=(dev)
-      @slapi.wiredump_dev=(dev)
-    end
-
-    # Get the WSDL, parse it, and save it to a Class level hash.
-    # Returns false of we couldn't parse the WSDL.
-    def self.cacheWSDL
-      return unless @@wsdl[self.soapClass].nil?
-
-      begin
-        # XXX: Silence soap4r's bogus use of Kernel#warn
-        v = $VERBOSE
-        $VERBOSE=nil
-        @@wsdl[self.soapClass] = SOAP::WSDLDriverFactory.new(self.wsdlUrl)
-        $VERBOSE = v
-        return true
-      rescue => e
-        return SoftLayer::Exception.new(:exception => e)
-      end 
-    end
-
-    # Return this Class's WSDL.
-    def self.wsdl
-      return @@wsdl[self.soapClass]
-    end
-
-    # Return this Class's WSDL URL.
-    def self.wsdlUrl
-      return URI.parse("#{WSDLBASE}/#{self.soapClass}#{WSDLPARAM}")
-    end
-
-    # Returns this Class's SOAP Class.
-    def self.soapClass
-      self.name.to_s.gsub(/::/, '_')
-    end
-
-    private
-
-    # Clean the headers out of the driver.
-    def headerClean(rl,ha)
-      @slapi.headerhandler.delete(rl)
-      ha.each { |h| @slapi.headerhandler.delete(h) }
-    end
-
-    # This really calls the soap method.
-    # This catches all exceptions, creates a copy of our exception proxy class
-    # and copies the message.  This insures exceptions make it up to user code
-    # as opposed to soap4r's tendancy to just exit when there's a soap exception.
-    #  todo:  Add header processing/clean up.
-    def realCall(m)
-      begin
-        return @slapi.call(m)
-      rescue => e
-        re = SoftLayer::Exception.new(:exception => e)
-        raise re
-      end
-    end
-
-  end
 end

data/lib/softlayer/baseclass.rb

@@ -0,0 +1,247 @@
+#!/usr/bin/env ruby
+# baseclass
+#
+# Author:: James Nuckolls
+# Copyright:: Copyright (c) 2009 SoftLayer. All rights reserved.
+#
+#= Description
+#
+#= ToDo
+#
+
+require 'rubygems' rescue LoadError
+gem 'soap4r'
+require 'soap/wsdlDriver'
+
+require 'softlayer'
+require 'softlayer/util'
+
+
+module SoftLayer
+  # The Base class for our generated class.
+  class BaseClass
+    attr_reader :slapi, :initParam
+
+    WSDLBASE='http://api.service.softlayer.com/soap/v3'
+    WSDLPARAM='?wsdl'
+
+    @@wsdl = { }
+    @@apiUser = nil
+    @@apiKey = nil
+
+    # The initializer.
+    # Arguments:
+    # +user+::  The API User
+    # +key+:: The API Key
+    # +initParams+:: This object's initParam (just the key)
+    # +debug+:: Enable debug after driver creation. (IO handler)
+    #
+    # +user+ and +key+ are optional.  The first time they're presented
+    # they're saved to class variables and reused later as necessary.  Supplying
+    # +user+ and +key+ later does not overwrite the class variables.  +initParams+ is
+    # required where the api requires it.
+    def initialize(args)
+      @apiUser = args[:user] unless args[:user].nil?
+      @apiKey = args[:key] unless args[:key].nil?
+      @initParam = args[:initParam]
+      @initParam = Param.new("#{self.soapClass}InitParameters", { 'id' => args[:initParam] }) unless args[:initParam].nil?
+
+      @@apiUser = args[:user] unless (args[:user].nil? || !@@apiUser.nil?)
+      @@apiKey = args[:key] unless (args[:key].nil? || !@@apiKey.nil?)
+      @apiUser = @@apiUser unless (@@apiUser.nil? || !@apiUser.nil?)
+      @apiKey = @@apiKey unless (@@apiKey.nil? || !@apiKey.nil?)
+      @authHeader = Param.new('authenticate', {'username' => @apiUser, 'apiKey' => @apiKey})
+
+      self.class.cacheWSDL
+      @slapi = @@wsdl[self.soapClass].create_rpc_driver unless @@wsdl[self.soapClass].nil?
+      raise SoftLayer::Exception.new(:message => 'WSDL endpoint not available.') if @slapi.nil?
+
+      self.debug=args[:debug] unless args[:debug].nil?
+    end
+
+    # Return this object's matching SLAPI SOAP Class.
+    def soapClass
+      return self.class.to_s.gsub(/::/, '_')
+    end
+
+    # This returns key values from this Service's associated Type (retrieved using #getObject).
+    def [](key)
+      @slapiObject = self.getObject if @slapiobject.nil?
+      return @slapiObject[key.to_s]
+    end
+
+    def setObject(obj)
+      @slapiObject = obj
+    end
+
+    # Set the object mask which ia passed as a hash of optional hashes (otherwise the hash elements should have a nil value).
+    # Using the example from the wiki:
+    #  <SoftLayer_AccountObjectMask xsi:type="v3:SoftLayer_AccountObjectMask">
+    #    <mask xsi:type="slt:SoftLayer_Account" xmlns:slt="http://api.service.softlayer.com/soap/v3/SLTypes/">
+    #        <domains>
+    #            <resourceRecords />
+    #        </domains>
+    #        <openTickets>
+    #            <assignedUser />
+    #            <attachedHardware />
+    #            <updates />
+    #        </openTickets>
+    #        <userCount />
+    #    </mask>
+    #  </SoftLayer_AccountObjectMask>
+    #
+    #  { 'domains' => { 'resourceRecords' => nil }, 'openTicket' => { 'assignedUser' => nil, 'attachedHardware' => nil, 'updates' => nil },
+    #   userCount => nil }
+    # Changing this resets the cached object used by #[]
+    def objectMask=(mask)
+      if mask.class == ObjectMask
+        @objectMask = mask
+      else
+        @objectMask = ObjectMask.new("#{self.soapClass}ObjectMask", mask)
+      end
+      @slapiObject = nil
+    end
+
+    def objectMask
+      return @objectMask
+    end
+
+    # Set an object wide result set (or clear it)
+    # arg can be one of three things:
+    # * nil clears the resultLimit
+    # * A Result Limit array of two elements range and offset.
+    # * An existing ResultLimit object
+    def resultLimit=(arg)
+      case arg.class
+      when NilClass
+        @resultLimit = nil
+      when Array
+        @resultLimit = ResultLimit.new('resultLimit',arg)
+      when ResultLimit
+        @resultLimit = arg
+      end
+    end
+
+    def resultLimit
+      return @resultLimit
+    end
+
+
+    # Make a direct api call.  The values of the paramaters are passed to the method 
+    # (the keys generally are not), unless it's a magic paramater.
+    # Magic Paramaters:
+    # +initParam+:: Initialization paramater for this call (just the key), therwise @initParam is used.
+    # +limit+:: A Result Limit array of two elements range and offset.  If @resultLimit is set it's used \
+    # if +limit+ is not and if neither is set, no limit is applied.
+    # +header+:: Extra headers to pass to the method in an array.
+    # 
+    # If a block is provided, the limit's range (or fewer) elements will yield to the block until the dataset
+    # is exhausted.  If no limit is provided with the block a limit of [1,0] is assumed initially (sorta).
+    # Aliased to #method_missing.
+    def slapiCall(method, args = {}, &block)      
+      initParam = args[:initParam] unless args[:initParam].nil?
+      args.delete(:initParam) unless args[:initParam].nil?
+      initParam = Param.new("#{self.soapClass}InitParameters", { 'id' => initParam }) unless initParam.nil?
+      initParam = @initParam if initParam.nil?
+      resultLimit = ResultLimit.new('resultLimit', args[:limit]) unless args[:limit].nil?
+      args.delete(:limit) unless args[:limit].nil?
+      resultLimit = @resultLimit if resultLimit.nil?
+      unroll = true if resultLimit.nil? && block_given?
+      resultLimit = ResultLimit.new('resultLimit', [5,0]) if resultLimit.nil? && block_given?
+      headers = args[:header]
+      args.delete(:header) unless args[:header].nil?
+
+      headers = [] if headers.nil?
+      headers << initParam unless @slapi.headerhandler.include?(initParam)
+      headers << @objectMask unless @objectMask.nil?
+      headers << resultLimit unless resultLimit.nil?
+      argshash = { :method => method, :headers => headers, :args => args }
+      argshash[:yield] = true if block_given?
+      catch :done do
+        while true do
+          res = realCall(argshash)
+          return res unless block_given?
+          return res if res.nil?
+          res.each { |e|  yield(e) } if unroll && res.respond_to?(:each)
+          yield(res) unless unroll || (res.respond_to?(:empty) && res.empty?)
+          throw :done if (res.respond_to?(:size) && (res.size < resultLimit.limit))
+          resultLimit.offset=resultLimit.offset + resultLimit.limit
+        end
+      end
+      headerClean(headers) if argshash[:yield]
+    end
+
+    # Alias the above slapiCall to #method_missing.
+    alias_method  :method_missing, :slapiCall
+    # Alias slapiCall to #call specifically because of it's special paramter list.
+    alias_method :call, :slapiCall
+
+    # Enable (or disable) debug. (paramater is the IO handler to write to)
+    def debug=(dev)
+      @slapi.wiredump_dev=(dev)
+    end
+
+    # Get the WSDL, parse it, and save it to a Class level hash.
+    # Returns false of we couldn't parse the WSDL.
+    def self.cacheWSDL
+      return unless @@wsdl[self.soapClass].nil?
+
+      begin
+        # XXX: Silence soap4r's bogus use of Kernel#warn
+        v = $VERBOSE
+        $VERBOSE=nil
+        @@wsdl[self.soapClass] = SOAP::WSDLDriverFactory.new(self.wsdlUrl)
+        $VERBOSE = v
+        return true
+      rescue => e
+        return SoftLayer::Exception.new(:exception => e)
+      end 
+    end
+
+    # Return this Class's WSDL.
+    def self.wsdl
+      return @@wsdl[self.soapClass]
+    end
+
+    # Return this Class's WSDL URL.
+    def self.wsdlUrl
+      return URI.parse("#{WSDLBASE}/#{self.soapClass}#{WSDLPARAM}")
+    end
+
+    # Returns this Class's SOAP Class.
+    def self.soapClass
+      self.name.to_s.gsub(/::/, '_')
+    end
+
+    private
+
+    # Clean the headers out of the driver.
+    def headerClean(ha)
+      ha.each { |h| @slapi.headerhandler.delete(h) }
+    end
+
+    # This really calls the soap method.
+    # This catches all exceptions, creates a copy of our exception proxy class
+    # and copies the message.  This insures exceptions make it up to user code
+    # as opposed to soap4r's tendancy to just exit when there's a soap exception.
+    #  todo:  Add header processing/clean up.
+    def realCall(args)
+      m = args[:method]
+      h = args[:headers]
+      a = args[:args]
+      y = args[:yield]
+      @slapi.headerhandler << @authHeader unless @slapi.headerhandler.include?(@authHeader)
+      h.each {|e| @slapi.headerhandler << e }
+      args = []
+      a.each { |k,v| args.push(v) }
+      begin
+        return @slapi.call(m.to_s, *args)
+      rescue => e
+        re = SoftLayer::Exception.new(:exception => e)
+        raise re
+      ensure
+        headerClean(h) unless y
+      end
+    end
+  end
+end

data/lib/softlayer/util.rb

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+# util
+#
+# Author:: James Nuckolls
+# Copyright:: Copyright (c) 2009 SoftLayer. All rights reserved.
+#
+#= Description
+#
+#= ToDo
+#
+
+require 'rubygems' rescue LoadError
+gem 'soap4r'
+require 'soap/header/simplehandler'
+
+
+module SoftLayer
+  # A class to old Paramaters.
+  class Param < SOAP::Header::SimpleHandler
+    def initialize(tag, out)
+      @out = out
+      super(XSD::QName.new(nil, tag))
+    end
+
+    def on_simple_outbound
+      @out
+    end
+
+    def [](k)
+      return @out[k]
+    end
+
+    def []=(k,v)
+      @out[k]=v
+    end
+  end
+
+  # A class to hold the object mask.
+  class ObjectMask < SOAP::Header::SimpleHandler
+
+    def initialize(tag, out)
+      @out = out
+      super(XSD::QName.new(nil, tag))
+    end
+
+    def on_simple_outbound
+      { 'mask' => @out }
+    end
+
+    def [](k)
+      @out[k]
+    end
+
+    def []=(k,v)
+      @out[k]=v
+    end
+  end
+
+  class ResultLimit < SOAP::Header::SimpleHandler
+    attr_accessor :limit, :offset
+
+    # limit should be an array of two elements; limit and offset.
+    def initialize(tag, limit)
+      @limit = limit[0]
+      @offset = limit[1]
+      super(XSD::QName.new(nil, tag))
+    end
+
+    def on_simple_outbound
+      { 'limit' => @limit, 'offset' => @offset }
+    end
+  end
+
+
+  # An Exception proxy class
+  # Not every exception soap4r returns decends from RuntimeError.
+  class Exception < RuntimeError
+
+    def initialize(args)
+      e = args[:exception]
+      message = args[:message] unless args[:message].nil?
+      message = e.message unless e.nil?
+      super(message)
+
+      @realException = e unless e.nil?
+      @realException = self if @realException.nil?
+    end
+  end
+end

data/sample/cdnlayerupload.rb

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+# cdnlayerupload
+#
+# Copyright (c) 2009, James Nuckolls. All rights reserved.
+# 
+#  Redistribution and use in source and binary forms, with or without
+#  modification, are permitted provided that the following conditions are met:
+# 
+#   * Redistributions of source code must retain the above copyright notice,
+#     this list of conditions and the following disclaimer.
+#   * Redistributions in binary form must reproduce the above copyright notice,
+#     this list of conditions and the following disclaimer in the documentation
+#     and/or other materials provided with the distribution.
+#   * Neither "James Nuckolls" nor the names of any contributors may
+#     be used to endorse or promote products derived from this software without
+#     specific prior written permission.
+# 
+#  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+#  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+#  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+#  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+#  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+#  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+#  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+#  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+#  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+#  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+#  POSSIBILITY OF SUCH DAMAGE.
+#
+#= Description
+#  Retrieves the current Account's BillingItems using an objectMask and outputs a report of the
+#  current (not-canceled) items.
+#= ToDo
+#
+
+require 'rubygems' rescue LoadError
+require 'ftools'
+require 'pp'
+require 'softlayer'
+
+AUTH_USER = ARGV[0]
+AUTH_KEY = ARGV[4]
+ACCT_ID = ARGV[1]
+CDN_ACCT = ARGV[2]
+INFILE = ARGV[3]
+
+SLAPICLASSES = [ 'SoftLayer::Account', 'SoftLayer::Network::ContentDelivery::Account' ]
+SoftLayer::declareClasses(:ruby => SLAPICLASSES)
+account = SoftLayer::Account.new(:user => AUTH_USER, :key => AUTH_KEY, :initParam => ACCT_ID)
+account.objectMask={'cdnAccountName' => nil}
+cdnacct = nil
+
+# Get the accout number by matching the name that was in ARGV[2]
+account.getCdnAccounts.each do |c|
+  # pp c
+  cdnacct = SoftLayer::Network::ContentDelivery::Account.new(:initParam => c['id']) if c['cdnAccountName'] == CDN_ACCT
+end
+
+cdnacct.getPopNames
+
+fname = File.basename(INFILE)
+# base64 encode the file
+b64 = [IO.read(INFILE)].pack("m")
+# cdnacct.debug=STDOUT
+ret = cdnacct.uploadStream(:source => { 'data' => b64, 'filename' => fname}, :target => "/media/http/test")
+pp ret
+
+

data/sample/resultlimit.rb

@@ -46,6 +46,7 @@ SoftLayer::declareClasses(:ruby => SLAPICLASSES)
 range = 5
 offset = 0
 account = SoftLayer::Account.new(:user => AUTH_USER, :key => AUTH_KEY, :initParam => ACCT_ID)
+
 # account.debug=STDOUT
 bia = account.getAllBillingItems(:limit => [range,offset])
 pp bia
@@ -61,11 +62,13 @@ account.getAllBillingItems(:limit => [range,offset]) do |bi|
   offset = range + offset
 end
 
-range = 5
+range = 1
 offset = 0
-# account.debug=STDOUT
-account.getInvoices(:limit => [range,offset]) do |bi|
+account.getInvoices do |bi|
   pp bi
   puts "================== #{offset}"
   offset = offset + range
 end
+
+exit 0
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: jamesn-softlayer-ruby
 version: !ruby/object:Gem::Version 
-  version: 0.6.3.0
+  version: 0.7.0.0
 platform: ruby
 authors: 
 - James Nuckolls
@@ -9,7 +9,7 @@ autorequire: softlayer
 bindir: bin
 cert_chain: []
 
-date: 2009-04-19 21:00:00 -07:00
+date: 2009-04-27 22:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -34,10 +34,13 @@ extra_rdoc_files:
 - Changes
 files: 
 - lib/softlayer.rb
+- lib/softlayer/baseclass.rb
+- lib/softlayer/util.rb
 - sample/nascapacity.rb
 - sample/billingreport.rb
 - sample/objectmask.rb
 - sample/resultlimit.rb
+- sample/cdnlayerupload.rb
 - README
 - LICENSE
 - Changes