clientside_aws 0.0.17

data/clientside_aws/ec2.rb

@@ -0,0 +1,103 @@
+require 'ipaddr'
+
+helpers do
+  def hkey_from_params(params)
+    "#{params['IpPermissions.1.IpProtocol']}:" \
+    "#{params['IpPermissions.1.FromPort']}:" \
+    "#{params['IpPermissions.1.ToPort']}"
+  end
+
+  def authorize_security_group_ingress(params)
+    hkey = hkey_from_params(params)
+    existing = AWS_REDIS.hget("ingress:#{params['GroupId']}",
+                              hkey)
+    value = existing ? JSON.parse(existing).to_set : Set.new
+    ip_addr = IPAddr.new(params['IpPermissions.1.IpRanges.1.CidrIp'])
+    mask = params['IpPermissions.1.IpRanges.1.CidrIp'].split('/').last
+    # Interpret the mask, so 10.0.0.1/24 converts to 10.0.0.0/24
+    value << "#{ip_addr}/#{mask}"
+
+    AWS_REDIS.hset("ingress:#{params['GroupId']}",
+                   hkey,
+                   value.to_a.to_json)
+  end
+
+  def revoke_security_group_ingress(params)
+    hkey = hkey_from_params(params)
+    value = AWS_REDIS.hget("ingress:#{params['GroupId']}", hkey)
+
+    return unless value
+
+    new_value = JSON.parse(value).reject do |r|
+      r == params['IpPermissions.1.IpRanges.1.CidrIp']
+    end
+
+    if new_value.length.positive?
+      AWS_REDIS.hset("ingress:#{params['GroupId']}", hkey, new_value.to_json)
+    else
+      AWS_REDIS.hdel("ingress:#{params['GroupId']}", hkey)
+    end
+  end
+
+  def describe_security_groups
+    group_id = params['GroupId.1']
+
+    xml = Builder::XmlMarkup.new
+    xml.instruct!
+    xmlns = 'http://ec2.amazonaws.com/doc/2016-11-15/'
+    xml.DescribeSecurityGroupsResponse(xmlns: xmlns) do
+      xml.tag!(:requestId, SecureRandom.hex(10))
+      xml.securityGroupInfo do
+        xml.item do
+          xml.tag!(:ownerId, SecureRandom.hex(10))
+          xml.tag!(:groupId, group_id)
+          xml.tag!(:groupName, 'group-name')
+          xml.tag!(:groupDescription, 'group-description')
+          xml.tag!(:vpcId, 'vpc-00000000')
+          xml.ipPermissions do
+            AWS_REDIS.hkeys("ingress:#{group_id}").each do |protocol_port_tuple|
+              xml.item do
+                (protocol, from_port, to_port) = protocol_port_tuple.split(':')
+
+                xml.tag!(:ipProtocol, protocol)
+                xml.tag!(:fromPort, from_port.to_i)
+                xml.tag!(:toPort, to_port.to_i)
+                xml.tag!(:groups, nil)
+
+                xml.ipRanges do
+                  ingress_permissions = \
+                    AWS_REDIS.hget("ingress:#{group_id}", protocol_port_tuple)
+                  JSON.parse(ingress_permissions).each do |cidr_ip|
+                    xml.item do
+                      xml.tag!(:cidrIp, cidr_ip)
+                    end
+                  end
+                end
+                xml.tag!(:ipv6Ranges, nil)
+                xml.tag!(:prefixListIds, nil)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    content_type :xml
+    xml.target!
+  end
+end
+
+post %r{/ec2(\.(\w+?)\.amazonaws\.com)?/?(.*)} do
+  case params[:Action]
+  when 'AuthorizeSecurityGroupIngress'
+    authorize_security_group_ingress(params)
+
+    200
+  when 'RevokeSecurityGroupIngress'
+    revoke_security_group_ingress(params)
+
+    200
+  when 'DescribeSecurityGroups'
+    describe_security_groups
+  end
+end

data/clientside_aws/elastic_transcoder.rb

@@ -0,0 +1,179 @@
+helpers do
+  def encode_video(source_key, dest_key, pipeline_id)
+    pipeline = JSON.parse(AWS_REDIS.get("pipeline:#{pipeline_id}"))
+    bucket = pipeline['InputBucket']
+    input_obj_name = source_key
+    input_obj_key = "s3:bucket:#{bucket}:#{input_obj_name}"
+
+    bucket = pipeline['OutputBucket']
+    output_obj_name = dest_key
+    output_obj_key = "s3:bucket:#{bucket}:#{output_obj_name}"
+    input_obj_body = AWS_REDIS.hget input_obj_key, 'body'
+
+    tmp = Tempfile.new(source_key)
+    tmp.write(input_obj_body)
+    tmp.close
+
+    # Setup paths
+    encoded_path = tmp.path + '.enc'
+    faststart_path = tmp.path + '.fast'
+    final_path = nil
+
+    # Android is already encoded; ios needs re-encoding
+    # Everyone gets faststart treatment
+    ffmpeg_video(tmp.path, encoded_path)
+
+    if File.exist?(encoded_path)
+      final_path = if faststart_video(encoded_path, faststart_path)
+                     faststart_path
+                   else
+                     encoded_path
+                   end
+    end
+
+    if final_path && File.exist?(final_path)
+      # Write
+      file = File.open(final_path, 'rb')
+      video = file.read
+      file.close
+
+      AWS_REDIS.hset output_obj_key, 'body', video
+      AWS_REDIS.hset output_obj_key, 'content-type', 'video/mp4'
+
+      begin
+        File.delete(final_path) if File.exist?(final_path)
+      rescue Exception => e
+      end
+      begin
+        File.delete(encoded_path) if File.exist?(encoded_path)
+      rescue Exception => e
+      end
+      begin
+        File.delete(faststart_path) if File.exist?(faststart_path)
+      rescue Exception => e
+      end
+      begin
+        tmp.delete
+      rescue Exception => e
+      end
+    end
+  end
+
+  def ffmpeg_video(path, output)
+    flip = nil
+    transpose = nil
+    info = `avprobe #{path} 2>&1`
+    match = info.match(/rotate\s+:\s(\d+)\s/)
+    if match
+      rotation = match[1]
+      if rotation == '90'
+        transpose = 1
+      elsif rotation == '270'
+        transpose = 2
+      elsif rotation == '180'
+        flip = true
+      end
+    end
+
+    args = []
+
+    args << 'avconv'
+    args << '-y'
+
+    args << '-i'
+    args << path
+
+    args << '-f'
+    args << 'mp4'
+
+    if transpose
+      args << '-vf'
+      args << "transpose=#{transpose}"
+    elsif flip
+      args << '-vf'
+      args << 'vflip,hflip'
+    end
+
+    args << '-b:v'
+    args << '900k'
+
+    args << '-vcodec'
+    args << 'libx264'
+
+    args << '-ac'
+    args << '1'
+
+    args << '-ar'
+    args << '44100'
+
+    args << '-profile:v'
+    args << 'baseline'
+
+    # Just for avconv, because it complains about aac
+    args << '-strict'
+    args << 'experimental'
+
+    args << output + '-tmp'
+
+    encode_command = args.join(' ')
+    _results = `#{encode_command} 2>&1`
+
+    `mv #{output}-tmp #{output} 2>&1`
+  end
+
+  def faststart_video(path, output)
+    unless `which qt-faststart`.empty?
+      `qt-faststart #{path} #{output}`
+      return true
+    end
+
+    false
+  end
+
+  def create_job(args)
+    input_obj_name = args['Input']['Key']
+    output_obj_name = args['Output']['Key']
+    pipeline_id = args['PipelineId']
+
+    encode_video(input_obj_name, output_obj_name, pipeline_id)
+
+    content_type 'application/x-amz-json-1.0'
+    { Job: {
+      Id: 1,
+      Input: args['Input'],
+      Output: args['Output'],
+      PipelineId: args['PipelineId']
+    } }.to_json
+  end
+
+  def create_pipeline(args)
+    if AWS_REDIS.get "pipeline:#{args['Name']}"
+      pipeline_id = AWS_REDIS.get "pipeline:#{args['Name']}"
+    else
+      pipeline_id = SecureRandom.hex(10) + args['OutputBucket']
+      AWS_REDIS.set "pipeline:#{pipeline_id}", args.to_json
+      AWS_REDIS.set "pipeline:#{args['Name']}", pipeline_id
+    end
+
+    content_type 'application/x-amz-json-1.0'
+    { Pipeline: {
+      Id: pipeline_id,
+      Name: args['Name'],
+      Status: 'Completed',
+      InputBucket: args['InputBucket'],
+      OutputBucket: args['OutputBucket'],
+      Role: args['Role'],
+      Notifications: args['Notifications']
+    } }.to_json
+  end
+end
+
+post %r{/elastictranscoder\.(.+?)\.amazonaws\.com/?(.*)?} do
+  args = JSON.parse(env['rack.input'].read)
+
+  if args['Input'] && args['Output']
+    create_job(args)
+  else
+    create_pipeline(args)
+  end
+end

data/clientside_aws/firehose.rb

@@ -0,0 +1,13 @@
+post %r{/firehose(\.(\w+?)\.amazonaws\.com)?/?(.*)} do
+  args = if env['REQUEST_METHOD'] == 'POST'
+           JSON.parse(env['rack.input'].read)
+         else
+           env['rack.request.form_hash']
+         end
+
+  AWS_REDIS.zadd "firehose:#{args['DeliveryStreamName']}",
+                 Time.now.to_i,
+                 Base64.decode64(args['Records'].to_json)
+
+  200
+end

data/clientside_aws/kinesis.rb

@@ -0,0 +1,13 @@
+post %r{/kinesis(\.(\w+?)\.amazonaws\.com)?/?(.*)} do
+  args = if env['REQUEST_METHOD'] == 'POST'
+           JSON.parse(env['rack.input'].read)
+         else
+           env['rack.request.form_hash']
+         end
+
+  AWS_REDIS.zadd "kinesis:#{args['StreamName']}",
+                 Time.now.to_i,
+                 Base64.decode64(args['Data'])
+
+  200
+end

data/clientside_aws/mock/core.rb

@@ -0,0 +1,7 @@
+module AWS
+  module Core
+    class << self
+      attr_accessor :testing
+    end
+  end
+end

data/clientside_aws/mock/firehose.rb

@@ -0,0 +1,14 @@
+module Aws
+  module Firehose
+    class Client
+      # Monkeypatch to save the last sent message
+      attr_reader :last_stream_name
+      attr_reader :last_records
+
+      def put_record_batch(delivery_stream_name:, records:)
+        @last_stream_name = delivery_stream_name
+        @last_records = records
+      end
+    end
+  end
+end

data/clientside_aws/mock/kinesis.rb

@@ -0,0 +1,18 @@
+module AWS
+  class Kinesis
+    class Client < Core::JSONClient
+      # Monkeypatch to save the last sent message
+      class V20131202
+        attr_reader :last_stream_name
+        attr_reader :last_data
+        attr_reader :last_partition_key
+
+        def put_record(stream_name:, data:, partition_key:)
+          @last_stream_name = stream_name
+          @last_data = data
+          @last_partition_key = partition_key
+        end
+      end
+    end
+  end
+end

data/clientside_aws/mock/s3.rb

@@ -0,0 +1,59 @@
+module AWS
+  class S3
+    class Bucket
+      begin
+        old_exists = instance_method(:exists?)
+        define_method(:exists?) do
+          begin
+            old_exists.bind(self).call
+          rescue Errors::NoSuchKey
+            false # bucket does not exist
+          end
+        end
+      rescue NameError
+        # aws-sdk-v1 is not being used
+      end
+    end
+
+    class PresignedPost
+      @@host = nil
+      @@port = nil
+      def self.mock_host=(host)
+        @@host = host
+      end
+
+      def self.mock_port=(port)
+        @@port = port
+      end
+
+      def mock_host
+        @@host || config.s3_endpoint.split(':').first
+      end
+
+      def mock_port
+        @@port || config.s3_endpoint.split(':')[1].split('/').first.to_i
+      end
+
+      def url
+        URI::HTTP.build(host: mock_host, path: "/s3/#{bucket.name}", port: mock_port)
+      end
+    end
+
+    # class Client < Core::Client
+    #   module Validators
+    #     # this keeps it from fucking up our hostname
+    #     def path_style_bucket_name?(_bucket_name)
+    #       true
+    #     end
+    #   end
+    # end
+
+    # class S3Object
+    #   def presign_v4(method, _options)
+    #     if method == :read || method == :get
+    #       "http://#{client.endpoint}/#{bucket.name}/#{key}"
+    #     end
+    #   end
+    # end
+  end
+end

data/clientside_aws/mock/ses.rb

@@ -0,0 +1,74 @@
+require 'uuid'
+
+module AWS
+  # Mock SES and enable retrieval of last message sent
+  # We also save messages to message_directory, if set
+  class SimpleEmailService
+    class SESMessage
+      def initialize
+        @id = SecureRandom.hex(10)
+      end
+
+      def successful?
+        true
+      end
+
+      def data
+        { message_id: @id }
+      end
+    end
+
+    @@message_directory = nil
+    @@sent_message = nil
+    @@sent_email = nil
+    def self.mock_clear_sent
+      @@sent_email = nil
+      @@sent_message = nil
+    end
+
+    def self.message_directory=(path)
+      @@message_directory = path
+    end
+
+    def self.mock_sent_email(clear = nil)
+      msg = @@sent_email
+      mock_clear_sent if clear
+      msg
+    end
+
+    def self.mock_sent_message(clear = nil)
+      msg = @@sent_message
+      mock_clear_sent if clear
+      msg
+    end
+
+    def quotas
+      { max_24_hour_send: 200, max_send_rate: 100.0, sent_last_24_hours: 22 }
+    end
+
+    def send_email(msg)
+      ses_message = SESMessage.new
+      to_adr = msg[:to]
+      from_adr = msg[:from]
+      _to_adr = to_adr[/(?<=<).*(?=>)/]
+      _from_adr = from_adr[/(?<=<).*(?=>)/]
+      fname = ses_message.data[:message_id]
+      log_msg("#{fname}.txt", "#{msg[:subject]}\n\n#{msg[:body_text]}") if msg[:body_text]
+      log_msg("#{fname}.html", msg[:body_html]) if msg[:body_html]
+      @@sent_email = msg
+      @@sent_message = ses_message
+      ses_message
+    end
+
+    private
+
+    def log_msg(file_name, content)
+      email_dir = @@message_directory
+      if email_dir
+        email_dir += '/' unless email_dir.end_with? '/'
+        FileUtils.mkdir_p(email_dir) unless File.directory?(email_dir)
+        File.open("#{email_dir}#{file_name}", 'w') { |file| file.write(content) }
+      end
+    end
+  end
+end