clientside_aws 0.0.17

data/clientside_aws/mock/sns.rb

@@ -0,0 +1,17 @@
+module AWS
+  class SNS
+    class Client < Core::QueryClient
+      # Monkeypatch to save the last sent message
+      class V20100331
+        attr_reader :last_msg
+
+        def publish(target_arn:,
+                    message_structure:,
+                    message:,
+                    message_attributes: nil)
+          @last_msg = message
+        end
+      end
+    end
+  end
+end

data/clientside_aws/s3.rb

@@ -0,0 +1,223 @@
+require 'builder'
+
+helpers do
+  def get_file(bucket:, file_name:)
+    halt 404, objectNotFound if AWS_REDIS.hget("s3:bucket:#{bucket}:#{file_name}", 'body').nil?
+
+    body = download_file(bucket, file_name)
+    content_type = AWS_REDIS.hget("s3:bucket:#{bucket}:#{file_name}", 'content-type')
+    response.headers['content-type'] = content_type.nil? ? 'html' : content_type
+    # response.headers["Content-Length"] = body.length.to_s
+    response.headers['etag'] = Digest::MD5.hexdigest(body)
+    response.body = body
+
+    status 200
+  end
+
+  def list_buckets
+    buckets = AWS_REDIS.keys 's3:bucket:*'
+
+    xml = Builder::XmlMarkup.new
+    xml.instruct!
+    xml.ListAllMyBucketsResult(xmlns: 'http://s3.amazonaws.com/doc/2006-03-01') do
+      xml.Owner do
+        xml.tag!(:ID, SecureRandom.hex(10))
+        xml.tag!(:DisplayName, 'Fake Owner')
+      end
+      xml.Buckets do
+        buckets.each do |bucket|
+          xml.Bucket do
+            xml.tag!(:Name, bucket.split(':').last)
+            xml.tag!(:CreationDate, Time.at(AWS_REDIS.hget(bucket, 'created_at').to_i).xmlschema)
+          end
+        end
+      end
+    end
+
+    content_type :xml
+    xml.target!
+  end
+
+  def list_objects(bucket)
+    xml = Builder::XmlMarkup.new
+    xml.instruct!
+    xml.ListBucketResult(xmlns: 'http://doc.s3.amazonaws.com/2006-03-01') do
+      objects = AWS_REDIS.keys "s3:bucket:#{bucket}:*"
+      xml.tag!(:Name, bucket)
+      xml.tag!(:KeyCount, objects.length)
+      xml.tag!(:Prefix, nil)
+      xml.tag!(:Marker, nil)
+      xml.tag!(:MaxKeys, 1000)
+      xml.tag!(:IsTruncated, false)
+
+      objects.each do |object|
+        prefix = params.key?('prefix') ? params['prefix'] : nil
+        next unless prefix.nil? || \
+                    object.start_with?("s3:bucket:#{bucket}:#{prefix}")
+
+        xml.Contents do
+          key = AWS_REDIS.hget object, 'key'
+          last_modified = AWS_REDIS.hget object, 'last_modified'
+          etag = AWS_REDIS.hget object, 'etag'
+          size = AWS_REDIS.hget object, 'size'
+
+          xml.tag!(:Key, key)
+          xml.tag!(:LastModified, Time.at(last_modified.to_i).xmlschema)
+          xml.tag!(:ETag, etag)
+          xml.tag!(:Size, size)
+          xml.tag!(:Storage, 'STANDARD')
+          xml.Owner do
+            xml.tag!(:ID, SecureRandom.hex(10))
+            xml.tag!(:DisplayName, 'fake@example.com')
+          end
+        end
+      end
+    end
+
+    content_type :xml
+    xml.target!
+  end
+
+  def objectNotFound
+    xml = Builder::XmlMarkup.new
+    xml.instruct!
+    xml.Error do
+      xml.tag!(:Code, 'NoSuchKey')
+      xml.tag!(:Message, 'The specified key does not exist.')
+    end
+    content_type :xml
+    xml.target!
+  end
+
+  def download_file(bucket, obj_name)
+    obj_key = "s3:bucket:#{bucket}:#{obj_name}"
+    (AWS_REDIS.hget obj_key, 'body').force_encoding('UTF-8')
+  end
+end
+
+# Get all of the buckets
+#   Host: s3[.-][us-mockregion-1].amazonaws.com
+get %r{/s3.*?\.amazonaws\.com/?} do
+  list_buckets
+
+  status 200
+end
+
+# Get bucket
+#   Host: bucket-name.s3[.-][us-mockregion-1].amazonaws.com
+get %r{/(.*?)\.(s3.*?\.amazonaws\.com)/?$} do
+  bucket = params[:captures][0]
+  halt 404 unless AWS_REDIS.exists "s3:bucket:#{bucket}"
+  list_objects(bucket)
+end
+
+# Get a file a bucket
+#   Host: bucket-name.s3[.-][us-mockregion-1].amazonaws.com/file-name
+get %r{/(.*?)\.(s3.*?\.amazonaws\.com)?/(.+)} do
+  bucket = params[:captures][0]
+  file_name = params[:captures][2]
+
+  get_file(bucket: bucket, file_name: file_name)
+end
+
+# Old-style way of referencing S3
+get %r{/s3/([^/]+)?/(.+)} do
+  bucket = params[:captures][0]
+  file_name = params[:captures][1]
+
+  get_file(bucket: bucket, file_name: file_name)
+end
+
+# Bucket creation
+#   Host: bucket-name.s3[.-][us-mockregion-1].amazonaws.com
+put %r{/(.*?)\.(s3\.?.*?\.amazonaws\.com)/?$} do
+  bucket = params[:captures][0]
+  AWS_REDIS.hset "s3:bucket:#{bucket}", 'created_at', Time.now.to_i
+
+  status 200
+end
+
+# Upload file into a bucket
+#   Host: bucket-name.s3[.-][us-mockregion-1].amazonaws.com/file-name
+put %r{/(.*?)\.s3\.(.*?\.amazonaws\.com)?/(.+)} do
+  bucket = params[:captures][0]
+  file_name = params[:captures][2]
+
+  # upload the file (chunking not implemented) to fake S3
+  if file_name && bucket
+    file_name = file_name[1..-1] if '/' == file_name[0]
+    clientside_aws_testing = \
+      defined?(Sinatra::Base.settings.clientside_aws_testing) && \
+      Sinatra::Base.settings.clientside_aws_testing
+    body_send = clientside_aws_testing ? params[:body] : request.body.read
+
+    # Handle the copy_XXX case
+    if body_send.nil? || body_send.empty?
+      %w(HTTP_X_AMZ_COPY_SOURCE x-amz-copy-source X-Amz-Copy-Source).each do |copy_source_key|
+        next unless env.key?(copy_source_key)
+        copy_source = env[copy_source_key]
+        if copy_source.start_with?('/')
+          (_extra, srcbucket, srcfile) = copy_source.split('/')
+        else
+          (srcbucket, srcfile) = copy_source.split('/')
+        end
+        body_send = download_file(srcbucket, srcfile)
+        break
+      end
+    end
+
+    if AWS_REDIS.hget("s3:bucket:#{bucket}:#{file_name}", 'size').to_i > 0 &&
+       (body_send.nil? || body_send.empty?) &&
+       env.key?('HTTP_X_AMZ_ACL')
+      # you are setting the ACL only on a file that already seems to exist
+      # Do not update the body
+    else
+      AWS_REDIS.hset "s3:bucket:#{bucket}:#{file_name}", 'body', body_send
+      AWS_REDIS.hset "s3:bucket:#{bucket}:#{file_name}", 'size', body_send.length
+    end
+
+    AWS_REDIS.hset "s3:bucket:#{bucket}:#{file_name}", 'key', file_name
+    AWS_REDIS.hset "s3:bucket:#{bucket}:#{file_name}", 'last_modified', Time.now.to_i
+    AWS_REDIS.hset "s3:bucket:#{bucket}:#{file_name}", 'etag', Digest::MD5.hexdigest(body_send)
+    AWS_REDIS.hset "s3:bucket:#{bucket}:#{file_name}", 'acl', env['HTTP_X_AMZ_ACL']
+
+    %w(content-type Content-Type CONTENT_TYPE).each do |content_type_key|
+      next unless env.key?(content_type_key)
+      AWS_REDIS.hset "s3:bucket:#{bucket}:#{file_name}",
+                     'content-type',
+                     env[content_type_key]
+      break
+    end
+  end
+
+  status 200
+end
+
+# Delete file from a bucket
+#   Host: bucket-name.s3[.-][us-mockregion-1].amazonaws.com/file-name
+delete %r{/(.*?)\.s3\.(.*?\.amazonaws\.com)?/(.+)} do
+  bucket = params[:captures][0]
+  file_name = params[:captures][2]
+  AWS_REDIS.del "s3:bucket:#{bucket}:#{file_name}"
+
+  status 200
+end
+
+# post %r{/s3(.*?\.amazonaws\.com)?/([^/]+)/?} do
+#   # upload the file (chunking not implemented) to fake S3
+#   bucket = params[:captures][1]
+#   file_name = params[:key]
+#   if file_name
+#     file_name = file_name[1..-1] if file_name.start_with? '/'
+#     body_send = params[:file]
+#     body_send = body_send[:tempfile].read unless AWS::Core.testing
+#
+#     AWS_REDIS.hset "s3:bucket:#{bucket}:#{file_name}", 'body', body_send
+#     if env.key?('content-type')
+#       AWS_REDIS.hset "s3:bucket:#{bucket}:#{file_name}", 'content-type', env['content-type']
+#     elsif env.key?('CONTENT_TYPE')
+#       AWS_REDIS.hset "s3:bucket:#{bucket}:#{file_name}", 'content-type', env['CONTENT_TYPE']
+#     end
+#   end
+#   status 200
+# end

data/clientside_aws/ses.rb

@@ -0,0 +1,9 @@
+post "/ses/?" do
+  # No-op for now
+  200
+end
+
+post %r{/ses(\.(\w+?)\.amazonaws\.com)?/(.*)} do
+  # No-op for now
+  200
+end

data/clientside_aws/sns.rb

@@ -0,0 +1,41 @@
+helpers do
+  def create_platform_endpoint(platform_application_arn:)
+    xml = Builder::XmlMarkup.new
+    xml.instruct!
+
+    xml.CreatePlatformEndpointResponse do
+      xml.CreatePlatformEndpointResult do
+        platform = if platform_application_arn =~ %r{app/APNS}
+                     'endpoint/APNS/'
+                   elsif platform_application_arn =~ %r{app/WNS}
+                     'endpoint/WNS/'
+                   elsif platform_application_arn =~ %r{app/GCM}
+                     'endpoint/GCM/'
+                   else
+                     'endpoint/UNKNOWN/'
+                   end
+
+        xml.tag!(:EndpointArn,
+                 'arn:aws:sns:us-east-1:999999999999:' \
+                 "#{platform}MYAPP/#{SecureRandom.hex(10)}")
+      end
+    end
+
+    content_type :xml
+    xml.target!
+  end
+end
+
+get %r{/sns\.(\w+?)\.amazonaws\.com/?(.*)} do
+  200
+end
+
+post %r{/sns(\.(\w+?)\.amazonaws\.com)?/?(.*)} do
+  case params[:Action]
+  when 'CreatePlatformEndpoint'
+    create_platform_endpoint(platform_application_arn:
+      params['PlatformApplicationArn'])
+  else
+    200
+  end
+end

data/clientside_aws/sqs.rb

@@ -0,0 +1,233 @@
+SQS_DEFAULT_VISIBILITY_TIMEOUT = \
+  (ENV['SQS_VISIBILITY_TIMEOUT'] || 60 * 60 * 6).to_i
+
+helpers do
+  def get_queue_url
+    queue_name = params[:QueueName]
+
+    xml = Builder::XmlMarkup.new
+    xml.instruct!
+
+    xml.GetQueueUrlResponse do
+      xml.GetQueueUrlResult do
+        xml.tag!(:QueueUrl, queue_name)
+      end
+      xml.ResponseMetadata do
+        xml.tag!(:RequestId, SecureRandom.hex(10))
+      end
+    end
+
+    content_type :xml
+    xml.target!
+  end
+
+  def get_queue_attributes
+    queue = params[:QueueUrl]
+
+    xml = Builder::XmlMarkup.new
+    xml.instruct!
+    xml.GetQueueAttributesResponse do
+      xml.GetQueueAttributesResult do
+        xml.Attribute do
+          xml.tag!(:Name, 'ApproximateNumberOfMessages')
+          xml.tag!(:Value, (AWS_REDIS.llen queue))
+        end
+        xml.Attribute do
+          xml.tag!(:Name, 'ApproximateNumberOfMessagesNotVisible')
+          xml.tag!(:Value, (AWS_REDIS.keys 'sqs:pending:*').length)
+        end
+      end
+      xml.ResponseMetadata do
+        xml.tag!(:RequestId, SecureRandom.hex(10))
+      end
+    end
+
+    content_type :xml
+    xml.target!
+  end
+
+  def delete_message
+    AWS_REDIS.del("sqs:pending:#{params['ReceiptHandle']}")
+    200
+  end
+
+  def delete_message_batch
+    deleted_messages = []
+    keys = params.keys.select { |k| k =~ /DeleteMessageBatchRequestEntry/ }
+    keys.each do |k|
+      AWS_REDIS.del("sqs:pending:#{params[k]}") if k =~ /ReceiptHandle$/
+      deleted_messages << params[k] if k =~ /Id$/
+    end
+
+    xml = Builder::XmlMarkup.new
+    xml.instruct!
+    xml.DeleteMessageBatchResponse do
+      xml.DeleteMessageBatchResult do
+        deleted_messages.each do |msg_id|
+          xml.DeleteMessageBatchResultEntry do
+            xml.tag!(:Id, msg_id)
+          end
+        end
+      end
+      xml.ResponseMetadata do
+        xml.tag!(:RequestId, SecureRandom.hex(10))
+      end
+    end
+
+    content_type :xml
+    xml.target!
+  end
+
+  def receive_message
+    queue = params[:QueueUrl]
+    max_messages = params[:MaxNumberOfMessages].to_i
+    max_messages = 1 if max_messages.zero?
+
+    xml = Builder::XmlMarkup.new
+    xml.instruct!
+
+    if AWS_REDIS.llen(queue).zero?
+      xml.ReceiveMessageResponse do
+        xml.ReceiveMessageResult do
+        end
+        xml.ResponseMetadata do
+          xml.tag!(:RequestId, SecureRandom.hex(10))
+        end
+      end
+
+      return xml.target!
+    end
+
+    results_json = []
+    max_messages.times do
+      raw_message = AWS_REDIS.rpop queue
+      results_json << JSON.parse(raw_message.force_encoding('UTF-8'))
+      break if (AWS_REDIS.llen queue).zero?
+    end
+
+    xml.ReceiveMessageResponse do
+      xml.ReceiveMessageResult do
+        results_json.each do |result|
+          xml.Message do
+            xml.tag!(:MessageId, result['MessageId'])
+            xml.tag!(:ReceiptHandle, result['ReceiptHandle'])
+            xml.tag!(:MD5OfBody, Digest::MD5.hexdigest(result['MessageBody']))
+            xml.tag!(:Body, result['MessageBody'])
+            xml.Attribute do
+              xml.tag!(:Name, 'SenderId')
+              xml.tag!(:Value, '1')
+            end
+            xml.Attribute do
+              xml.tag!(:Name, 'SentTimestamp')
+              xml.tag!(:Value, result['Timestamp'])
+            end
+            xml.Attribute do
+              xml.tag!(:Name, 'ReceiptHandle')
+              xml.tag!(:Value, result['Timestamp'])
+            end
+            xml.Attribute do
+              xml.tag!(:Name, 'ApproximateReceiveCount')
+              xml.tag!(:Value, '1')
+            end
+            xml.Attribute do
+              xml.tag!(:Name, 'ApproximateFirstReceiveTimestamp')
+              xml.tag!(:Value, result['Timestamp'] * 1000)
+            end
+          end
+          redis_key = "sqs:pending:#{result['ReceiptHandle']}"
+          payload = { queue: queue, message: result, received: Time.now }
+          AWS_REDIS.set(redis_key, payload.to_json)
+        end
+      end
+      xml.ResponseMetadata do
+        xml.tag!(:RequestId, results_json.first['RequestId'])
+      end
+    end
+
+    content_type :xml
+    xml.target!
+  end
+
+  def send_message_batch
+    queue = params[:QueueUrl]
+    idx = 1
+    loop do
+      break unless params["SendMessageBatchRequestEntry.#{idx}.MessageBody"]
+      send_message(queue, params["SendMessageBatchRequestEntry.#{idx}.MessageBody"])
+      idx += 1
+    end
+
+    halt 200
+  end
+
+  def send_message(queue, message_body)
+    message_id = SecureRandom.hex(10)
+    request_id = SecureRandom.hex(10)
+    msg = {
+      MessageBody: message_body,
+      MessageId: message_id,
+      RequestId: request_id,
+      Timestamp: Time.now.to_i,
+      ReceiptHandle: Base64.encode64(message_id).strip
+    }
+    AWS_REDIS.lpush(queue, msg.to_json)
+
+    xml = Builder::XmlMarkup.new
+    xml.instruct!
+    xml.SendMessageResponse do
+      xml.SendMessageResult do
+        xml.tag!(:MD5OfMessageBody, Digest::MD5.hexdigest(message_body))
+        xml.tag!(:MessageId, message_id)
+      end
+      xml.ResponseMetadata do
+        xml.tag!(:RequestId, request_id)
+      end
+    end
+
+    content_type :xml
+    xml.target!
+  end
+
+  def __check_pending
+    AWS_REDIS.keys('sqs:pending:*').each do |key|
+      json = AWS_REDIS.get(key).to_s.force_encoding("UTF-8")
+      begin
+        payload = JSON.parse(json)
+        time_received = Time.parse(payload['received'])
+        since_received = Time.now - time_received
+
+        if since_received > SQS_DEFAULT_VISIBILITY_TIMEOUT
+          AWS_REDIS.lpush(payload['queue'], payload['message'].to_json)
+          AWS_REDIS.del(key)
+        end
+      rescue => e
+        puts "INVALID PENDING PAYLOAD: #{e.message} #{json} #{e.backtrace}"
+        STDOUT.flush
+        AWS_REDIS.del(key)
+      end
+    end
+  end
+end
+
+post %r{/sqs(\.(\w+?)\.amazonaws\.com)?/?(.*)} do
+  case params[:Action]
+  when 'SendMessage'
+    send_message(params[:QueueUrl], params[:MessageBody])
+  when 'SendMessageBatch'
+    send_message_batch
+  when 'ReceiveMessage'
+    __check_pending
+    receive_message
+  when 'DeleteMessage'
+    delete_message
+  when 'DeleteMessageBatch'
+    delete_message_batch
+  when 'GetQueueAttributes'
+    __check_pending
+    get_queue_attributes
+  when 'GetQueueUrl'
+    get_queue_url
+  else
+    halt 500, "Unknown action #{params.inspect}"
+  end
+end