ruby-aws 1.6.0

data/lib/amazon/webservices/mturk/question_generator.rb

@@ -0,0 +1,58 @@
+# Copyright:: Copyright (c) 2007 Amazon Technologies, Inc.
+# License::   Apache License, Version 2.0
+
+require 'rexml/element'
+
+module Amazon
+module WebServices
+module MTurk
+
+class QuestionGenerator
+
+  def self.build(type=:Basic)
+    question = self.new(type)
+    yield question
+    return question.to_xml
+  end
+  
+  def initialize(type=:Basic)
+    @overview = nil
+    @questions = []
+    @type = type
+  end
+  
+  def ask(*args)
+    case @type
+    when :Basic
+      askBasic( args.join )
+    end
+  end
+  
+  def askBasic(text)
+    id = "BasicQuestion#{@questions.size+1}"
+    question = REXML::Element.new 'Text'
+    question.text = text
+    answerSpec = "<FreeTextAnswer/>"
+    @questions << { :Id => id, :Question => question.to_s, :AnswerSpec => answerSpec }
+  end
+  
+  def to_xml
+    components = [PREAMBLE]
+    components << OVERVIEW % @overview unless @overview.nil?
+    for question in @questions
+      components << QUESTION % [ question[:Id], question[:Question], question[:AnswerSpec] ]
+    end
+    components << [TAIL]
+    return components.join    
+  end
+  
+  PREAMBLE = '<?xml version="1.0" encoding="UTF-8"?>'+"\n"+'<QuestionForm xmlns="http://mechanicalturk.amazonaws.com/AWSMechanicalTurkDataSchemas/2005-10-01/QuestionForm.xsd">'
+  OVERVIEW = '<Overview>%s</Overview>'
+  QUESTION = '<Question><QuestionIdentifier>%s</QuestionIdentifier><QuestionContent>%s</QuestionContent><AnswerSpecification>%s</AnswerSpecification></Question>'
+  TAIL = '</QuestionForm>'
+  
+end # QuestionGenerator
+
+end # Amazon::WebServices::MTurk
+end # Amazon::WebServices
+end # Amazon

data/lib/amazon/webservices/util/amazon_authentication_relay.rb

@@ -0,0 +1,72 @@
+# Copyright:: Copyright (c) 2007 Amazon Technologies, Inc.
+# License::   Apache License, Version 2.0
+
+require 'amazon/webservices/util/command_line'
+require 'amazon/webservices/util/request_signer'
+
+module Amazon
+module WebServices
+module Util
+
+class AmazonAuthenticationRelay
+
+  REQUIRED_PARAMETERS = [:Name,:Transport]
+
+  def initialize( args )
+    missing_parameters = REQUIRED_PARAMETERS - args.keys
+    raise "Missing paramters: #{missing_parameters.join(',')}" unless missing_parameters.empty?
+    @name = args[:Name]
+    @transport = args[:Transport]
+    @keyId, @key = findAuthInfo( args )
+  end
+
+  def withCredential(credential,method,*request)
+    time = Time.now.gmtime.strftime('%Y-%m-%dT%H:%M:%S.123Z')
+    request[0] ||= {}
+    args = { :AWSAccessKeyId => @keyId,
+             :Timestamp => time,
+             :Signature => RequestSigner.sign(@name,method,time,@key),
+             :Credential => credential,
+             :Request => request }
+    @transport.send( method, args )
+  end
+
+  def method_missing(method, *request)
+    time = Time.now.gmtime.strftime('%Y-%m-%dT%H:%M:%S.321Z')
+    request[0] ||= {}
+    args = { :AWSAccessKeyId => @keyId,
+             :Timestamp => time,
+             :Signature => RequestSigner.sign(@name,method,time,@key),
+             :Request => request }
+    @transport.send( method, args )
+  end
+
+  def to_s
+    "AmazonAuthenticationRelay[name:#{@name} transport:#{@transport}]>"
+  end
+
+  def inspect
+    "#<Amazon::WebServices::Util::AmazonAuthenticationRelay:#{object_id} name:#{@name} transport:#{@transport.inspect}>"
+  end
+
+  private
+
+  def findAuthInfo( args )
+    if args.has_key? :AWSAccessKey or args.has_key? :AWSAccessKeyId
+      # user tried to pass authentication information in, so just use that
+      raise "Missing AWSAccessKeyId" if args[:AWSAccessKeyId].nil?
+      raise "Missing AWSAccessKey" if args[:AWSAccessKey].nil?
+      return args[:AWSAccessKeyId], args[:AWSAccessKey]
+    else
+      # didn't get passed in, so load from config or go interactive
+      cmd = CommandLine.new
+      cmd.checkAuthConfig
+      return cmd.authId, cmd.authKey
+    end
+  end
+
+end # AmazonAuthenticationRelay
+
+end # Amazon::WebServices::Util
+end # Amazon::WebServices
+end # Amazon

data/lib/amazon/webservices/util/command_line.rb

@@ -0,0 +1,157 @@
+# Copyright:: Copyright (c) 2007 Amazon Technologies, Inc.
+# License::   Apache License, Version 2.0
+
+require 'optparse'
+require 'highline'
+require 'amazon/util/user_data_store'
+
+module Amazon
+module WebServices
+module Util
+
+class CommandLine
+
+  SDKS = ['Mechanical Turk']
+
+  MISSING_AUTH = "You are missing authentication information required to utilize Amazon Web Services.  You will now be prompted for your <%= color('Access Key ID',BOLD) %> and your <%= color('Secret Access Key',BOLD) %>.  If you do not have this information, please log into http://www.amazonaws.com/  \n\n"
+  RESUME_AUTH = "Authentication information has been initialized.  Continuing... \n\n"
+
+  MAIN_HELP = <<EOF
+
+This is the <%= color('RubyAWS', RED, BOLD) %> Command Line Application's Interactive mode.
+You got here by typing:
+
+  <%= color('$ ruby-aws',GREEN) %>
+
+This application currently supports the following functionality:
+
+<%= list( ['Amazon Web Services Authentication Configuration'] ) %>
+You can also invoke this tool with commandline parameters.  For more information:
+
+  <%= color('$ ruby-aws --help',GREEN) %>
+
+Thanks for using Amazon Web Services!
+
+EOF
+
+  def initialize( interactive = true )
+    @interactive = interactive
+    @h = HighLine.new
+    @h.wrap_at = :auto
+    @store = Amazon::Util::UserDataStore.new :AWS
+    HighLine.use_color = useColor?
+    HighLine.track_eof = false # disabling because it misbehaves
+  end
+
+  def checkAuthConfig
+    if @store.get(:Auth,:AccessKeyId).nil? or @store.get(:Auth,:SecretAccessKey).nil?
+      @h.say MISSING_AUTH
+      getAuthConfig
+      @h.say RESUME_AUTH
+    end
+  end
+
+  def getAuthConfig( default={} )
+    id = @h.ask( 'What is your Access Key ID?' ) {|q| q.validate = /^[A-Z0-9]{20}$/ ; q.default = authId.to_s ; q.first_answer = default[:ID] }
+    key = @h.ask( 'What is your Secret Access Key?' ) {|q| q.validate = /^[\w\/+]{40}$/ ; q.default = authKey.to_s ; q.first_answer = default[:Key] }
+
+    @store.set(:Auth,:AccessKeyId,id)
+    @store.set(:Auth,:SecretAccessKey,key)
+
+    should_save = @h.agree( 'Would you like to save your authentication information?' )
+    @store.save if should_save
+  rescue
+    raise "Unable to retrieve authentication information from the Console"
+  end
+
+  def authKey
+    @store.get(:Auth,:SecretAccessKey)
+  end
+  def authId
+    @store.get(:Auth,:AccessKeyId)
+  end
+
+  def useColor?
+    if @store.get(:Misc,:ColorTerminal).nil?
+      if @interactive and @h.agree( "Should the console application use color? (y/n)" )
+        @store.set(:Misc,:ColorTerminal,true)
+      else
+        @store.set(:Misc,:ColorTerminal,false)
+      end
+      @store.save
+    end
+    return @store.get(:Misc,:ColorTerminal)
+  end
+
+  def toggleColor
+    value = !useColor?
+    @store.set(:Misc,:ColorTerminal,value)
+    HighLine.use_color = value
+  end
+
+  def default_menu
+    loop do
+      @h.choose do |menu|
+        menu.header = "\n" + @h.color('RubyAWS',HighLine::BOLD,HighLine::RED) + " " + @h.color('Command Line Application',HighLine::BOLD) + " " + @h.color('[Interactive Mode]',HighLine::GREEN,HighLine::BOLD)
+        menu.select_by = :index
+        menu.choice( 'Configure Amazon Web Services Authentication' ) do
+          if @h.agree( "\nCurrent ID: #{@h.color(authId,HighLine::BOLD)}\nCurrent Key: #{@h.color(authKey,HighLine::BOLD)}\nDo you want to change?" )
+            getAuthConfig
+          end
+        end
+        menu.choice( 'Toggle Color' ) { toggleColor }
+        menu.choice( :help ) do
+          @h.say MAIN_HELP
+        end
+        menu.choice( 'Save and Quit' ) { @store.save ; exit }
+        menu.prompt = "\nWhat would you like to do? "
+      end
+    end
+  end
+
+  def parseOptions
+    res = {}
+    opts = OptionParser.new
+
+    opts.on( '-i', '--interactive', 'Load Interactive Mode' ) { res[:Interactive] = true }
+    opts.on( '-a', '--authenticate', 'Configure Authentication Options' ) { res[:Auth] = true }
+    opts.on( '--id=ID', 'Set Access Key ID (requires "-a")' ) { |id| res[:ID] = id }
+    opts.on( '--key=KEY', 'Set Secret Access Key (requires "-a")' ) { |key| res[:Key] = key }
+
+    begin
+      opts.parse(ARGV)
+      raise "-i and -a are exclusive options.  Please pick one." if res[:Interactive] and res[:Auth]
+      raise "--id requires -a" if res[:ID] and !res[:Auth]
+      raise "--key requires -a" if res[:Key] and !res[:Auth]
+      res[:Mode] = res[:Auth] ? :Auth : :Interactive
+    rescue => e
+      p e.message
+    end
+    res
+  end
+
+  def run
+
+    opts = parseOptions
+
+    case opts[:Mode]
+    when :Interactive
+
+      @h.say "\n<%= color('Welcome to',BOLD) %> <%= color('RubyAWS #{RubyAWS::VERSION}',BOLD,RED) %>"
+      @h.say "This version includes SDK extensions for: <%= list (#{SDKS.inspect}.collect {|a| color(a,BOLD)}), :inline, ' and ' %>\n\n"
+
+      checkAuthConfig
+
+      default_menu
+    when :Auth
+
+      getAuthConfig( :Key => opts[:Key], :ID => opts[:ID] )
+
+    end
+  end
+
+end
+
+end # Amazon::WebServices::Util
+end # Amazon::WebServices
+end # Amazon::WebServices

data/lib/amazon/webservices/util/convenience_wrapper.rb

@@ -0,0 +1,90 @@
+# Copyright:: Copyright (c) 2007 Amazon Technologies, Inc.
+# License::   Apache License, Version 2.0
+
+require 'amazon/util'
+
+module Amazon
+module WebServices
+module Util
+
+class ConvenienceWrapper
+  include Amazon::Util::Logging
+
+  REQUIRED_PARAMETERS = [:ServiceClass]
+
+  def initialize(args)
+    missing_parameters = REQUIRED_PARAMETERS - args.keys
+    raise "Missing paramters: #{missing_parameters.join(',')}" unless missing_parameters.empty?
+    @service = args[:ServiceClass].new( args )
+  end
+
+  def callService( method, *args )
+    @service.send( method, *args )
+  end
+
+  def method_missing( method, *args )
+    if @service.respond_to? method
+      callService( method, *args )
+    else
+      callService( ConvenienceWrapper.real_method( method ), *args )
+    end
+  end
+
+  def self.serviceCall( method, responseTag, defaultArgs={} )
+    method = method.to_s
+    name = ( method[0..0].downcase + method[1..-1] ).to_sym
+    rawName = ( name.to_s + "Raw" ).to_sym
+    method = real_method( method )
+
+    raise 'Stop redifining service methods!' if self.instance_methods.include? name.to_s
+
+    define_method( rawName ) do |args|
+      log "Sending service request '#{name}' with args: #{args.inspect}"
+      result = callService( method, args )
+      return result[responseTag]
+    end
+
+    define_method( name ) do |*params|
+      userArgs = params[0] || {}
+      args = defaultArgs.merge( userArgs )
+      self.send rawName, args
+    end
+  end
+
+  def self.paginate( method, elementTag, pageSize=25 )
+    method = method.to_s
+    all_name = ( method[0..0].downcase + method[1..-1] + "All" ).to_sym
+    iterator_name = ( method[0..0].downcase + method[1..-1] + "Iterator" ).to_sym
+    proactive_name = ( method[0..0].downcase + method[1..-1] + "AllProactive" ).to_sym
+    method = ( method[0..0].downcase + method[1..-1] ).to_sym
+
+    raise 'Stop redifining service methods!' if self.instance_methods.include? name.to_s
+
+    processors = { all_name => Amazon::Util::LazyResults,
+                   iterator_name => Amazon::Util::PaginatedIterator,
+                   proactive_name => Amazon::Util::ProactiveResults }
+
+    processors.each do |name,processor|
+      define_method( name ) do |*params|
+        userArgs = params[0] || {}
+        args = {:PageSize => pageSize}.merge( userArgs ) # allow user to override page size
+        return processor.new do |pageNumber|
+          pageArgs = args.merge({:PageNumber => pageNumber}) # don't allow override of page number
+          res = self.send( method, pageArgs)[elementTag]
+          res.nil? ? nil : [res].flatten
+        end
+      end
+    end
+
+  end
+
+  def self.real_method( method )
+    method = method.to_s
+    method = ( method[0..0].upcase + method[1..-1] ).to_sym
+  end
+
+end # ConvenienceWrapper
+
+end # Amazon::WebServices::Util
+end # Amazon::WebServices
+end # Amazon

data/lib/amazon/webservices/util/filter_proxy.rb

@@ -0,0 +1,45 @@
+# Copyright:: Copyright (c) 2007 Amazon Technologies, Inc.
+# License::   Apache License, Version 2.0
+
+require 'amazon/util/filter_chain'
+
+module Amazon
+module WebServices
+module Util
+
+# Filter proxy is a class that can filter argument input before passing onto a proxy object
+# == Usage
+# Initialize with standard argument block, pass the class or pre-initialized object as the :FilterProxy parameter.
+# All parameters will be passed along to the contructor of the passed class.
+# FilterProxy exposes a FilterChain object, with all the magic which that class provides.
+class FilterProxy
+
+  attr_accessor :filter_chain
+  
+  def initialize(args)
+    @filter_chain = Amazon::Util::FilterChain.new
+  end
+
+  def configure(args)
+    @proxy = case args[:FilterProxy]
+      when Class
+        args[:FilterProxy].new( args )
+      when nil
+        raise "No FilterProxy or DefaultOverride defined!" unless args[:DefaultOverride].is_a? Proc
+        args[:DefaultOverride].call( args )
+      else
+        args[:FilterProxy]
+      end
+  end
+  
+  def method_missing(method, *args)
+    @filter_chain.execute(method, args) { |method,args|
+      @proxy.send(method,*args)
+    }
+  end
+  
+end
+
+end # Amazon::WebServices::Util
+end # Amazon::WebServices
+end # Amazon

data/lib/amazon/webservices/util/mock_transport.rb

@@ -0,0 +1,70 @@
+# Copyright:: Copyright (c) 2007 Amazon Technologies, Inc.
+# License::   Apache License, Version 2.0
+
+module Amazon
+module WebServices
+module Util
+
+class MockTransport
+  include Enumerable
+
+  class MethodCall
+
+    def initialize( name, args )
+      @name = name
+      @args = args
+      @request = args[:Request][0]
+    end
+
+    attr_reader :name, :args, :request
+
+  end
+
+  def initialize( args={} )
+    @call_buffer = []
+    @index = 0
+    @listener = nil
+    @mock_reply = args[:MockReply] || { :MockResult => { :Mock => true, :Request => {} }, :OperationRequest => {} }
+    @listener = args[:MockListener] if args[:MockListener].is_a? Proc
+  end
+
+  attr_reader :call_buffer
+  attr_accessor :mock_reply
+
+  def flush
+    @call_buffer = []
+    @index = 0
+  end
+
+  def next
+    return nil if @index >= @call_buffer.size
+    ret = @call_buffer[@index]
+    @index += 1
+    ret
+  end
+
+  def each(&block) # :yields: method_call
+    @call_buffer[@index..-1].each { |item| yield item }
+#    yield self.next until @index >= @call_buffer.size
+  end
+
+  def listen(&block) # :yields: method_call
+    @listener = block
+  end
+
+  def method_missing(method,*args)
+    raise "only support one parameter" unless args.size <= 1
+    the_method = MethodCall.new( method, args[0] )
+    @call_buffer << the_method
+    listen_result = @listener.call( the_method ) unless @listener.nil?
+    response = @mock_reply.dup
+    response[:MockResult][:Request] = the_method.request unless response[:MockResult].nil?
+    response.merge!(listen_result) if listen_result.is_a? Hash
+    response
+  end
+
+end
+
+end # Amazon::Webservices::Util
+end # Amazon::Webservices
+end # Amazon