ruby-aws 1.7.1 → 1.7.2

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

@@ -1,153 +0,0 @@
-# Copyright:: Copyright (c) 2007-2014 Amazon Technologies, Inc.
-# License::   Apache License, Version 2.0
-
-require 'amazon/util/logging'
-require 'amazon/webservices/util/validation_exception'
-require 'amazon/webservices/util/unknown_result_exception'
-
-module Amazon
-module WebServices
-module MTurk
-
-class MechanicalTurkErrorHandler
-  include Amazon::Util::Logging
-
-  REQUIRED_PARAMETERS = [:Relay]
-
-  # Commands with these prefixes can be retried if we are unsure of success
-  RETRY_PRE = %w( search get register update disable assign set dispose )
-
-  # Max number of times to retry a call
-  MAX_RETRY = 6
-
-  # Base used in Exponential Backoff retry delay
-  BACKOFF_BASE = 2
-  # Scale factor for Exponential Backoff retry delay
-  BACKOFF_INITIAL = 0.1
-
-  # Matching pattern to find a 'Results' element in the Response
-  RESULT_PATTERN = /Result/
-  # Additional elements to be considered a 'Result' despite not matching RESULT_PATTERN
-  ACCEPTABLE_RESULTS = %w( HIT Qualification QualificationType QualificationRequest Information )
-
-  def initialize( args )
-    missing_parameters = REQUIRED_PARAMETERS - args.keys
-    raise "Missing paramters: #{missing_parameters.join(',')}" unless missing_parameters.empty?
-    @relay = args[:Relay]
-  end
-
-  def dispatch(method, *args)
-    try = 0
-    begin
-      try += 1
-      log "Dispatching call to #{method} (try #{try})"
-      response = @relay.send(method,*args)
-      validateResponse( response )
-      return response
-    rescue Exception => error
-      case handleError( error,method,args )
-      when :RetryWithBackoff
-        retry if doBackoff( try )
-      when :RetryImmediate
-        retry if canRetry( try )
-      when :Ignore
-        return :IgnoredError => error
-      when :Unknown
-        raise Util::UnknownResultException.new( error, method, args )
-      when :Fail
-        raise error
-      else
-        raise "Unknown error handling method: #{handleError( error,method )}"
-      end
-      raise error
-    end
-  end
-
-  def methodRetryable( method )
-    RETRY_PRE.each do |pre|
-      return true if method.to_s =~ /^#{pre}/i
-    end
-    return false
-  end
-
-  def handleError( error, method, args )
-    log "Handling error: #{error.inspect}"
-    idempotent = args.none? {|params| params[:UniqueRequestToken].nil? || params[:UniqueRequestToken].empty? }
-    retryable = methodRetryable( method ) || idempotent
-
-    case error.class.to_s
-    when 'Timeout::Error','SOAP::HTTPStreamError','Errno::ECONNRESET','Errno::EPIPE'
-      if retryable
-        return :RetryImmediate
-      else
-        return :Unknown
-      end
-    when 'SOAP::FaultError'
-      case error.faultcode.data
-      when "aws:Server.ServiceUnavailable"
-        return :RetryWithBackoff
-      else
-        return :Unknown
-      end
-    when 'Amazon::WebServices::Util::ValidationException'
-      case error.message
-      when 'AWS.ServiceUnavailable'
-        return :RetryWithBackoff if retryable
-      end
-      return :Fail
-    when 'RuntimeError'
-      case error.message
-      when 'Throttled'
-        return :RetryWithBackoff
-      else
-        return :RetryImmediate
-      end
-    else
-      return :Unknown
-    end
-  end
-
-  def canRetry( try )
-    try <= MAX_RETRY
-  end
-
-  def doBackoff( try )
-    return false unless canRetry(try)
-    delay = BACKOFF_INITIAL * ( BACKOFF_BASE ** try )
-    sleep delay
-    return true
-  end
-
-  def isResultTag( tag )
-    tag.to_s =~ RESULT_PATTERN or ACCEPTABLE_RESULTS.include?( tag.to_s )
-  end
-
-  def validateResponse(response)
-    log "Validating response: #{response.inspect}"
-    if response[:Errors] and response[:Errors][:Error]
-      if response[:Errors][:Error][:Code] == "ServiceUnavailable"
-        raise 'Throttled'
-      else
-        raise Util::ValidationException.new(response)
-      end
-    end
-    if response[:OperationRequest] and response[:OperationRequest][:Errors]
-      raise Util::ValidationException.new(response)
-    end
-    resultTags = response.keys.find_all {|r| isResultTag( r ) }
-    raise Util::ValidationException.new(response, "Didn't get back an acceptable result tag (got back #{response.keys.join(',')})") if resultTags.empty?
-    resultTags.each do |resultTag|
-      log "using result tag <#{resultTag}>"
-      result = response[resultTag]
-      if result[:Request] and result[:Request][:Errors]
-        raise Util::ValidationException.new(result)
-      end
-    end
-    response
-  end
-
-end # MechanicalTurkErrorHandler
-
-end # Amazon::WebServices::MTurk
-end # Amazon::WebServices
-end # Amazon

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

@@ -1,58 +0,0 @@
-# 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

@@ -1,72 +0,0 @@
-# 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

@@ -1,157 +0,0 @@
-# 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

@@ -1,90 +0,0 @@
-# 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