S3 object options

lib/refile/s3.rb

@@ -30,6 +30,13 @@ class S3
 
     attr_reader :access_key_id, :max_size
 
+    S3_AVAILABLE_OPTIONS = {
+      client: %i(access_key_id region secret_access_key),
+      copy_from: %i(copy_source server_side_encryption storage_class),
+      presigned_post: %i(key server_side_encryption storage_class),
+      put: %i(body content_length server_side_encryption storage_class)
+    }
+
     # Sets up an S3 backend
     #
     # @param [String] region            The AWS region to connect to
@@ -42,7 +49,7 @@ class S3
     # @see http://docs.aws.amazon.com/AWSRubySDK/latest/AWS/S3.html
     def initialize(region:, bucket:, max_size: nil, prefix: nil, hasher: Refile::RandomHasher.new, **s3_options)
       @s3_options = { region: region }.merge s3_options
-      @s3 = Aws::S3::Resource.new @s3_options
+      @s3 = Aws::S3::Resource.new s3_options_for(:client)
       credentials = @s3.client.config.credentials
       raise S3CredentialsError unless credentials
       @access_key_id = credentials.access_key_id
@@ -60,12 +67,14 @@ def initialize(region:, bucket:, max_size: nil, prefix: nil, hasher: Refile::Ran
     verify_uploadable def upload(uploadable)
       id = @hasher.hash(uploadable)
 
-      if uploadable.is_a?(Refile::File) and uploadable.backend.is_a?(S3) and uploadable.backend.access_key_id == access_key_id
-        object(id).copy_from(copy_source: [@bucket_name, uploadable.backend.object(uploadable.id).key].join("/"))
+      operation, options = if upload_via_copy_operation?(uploadable)
+        [:copy_from, { copy_source: [@bucket_name, uploadable.backend.object(uploadable.id).key].join("/") }]
       else
-        object(id).put(body: uploadable, content_length: uploadable.size)
+        [:put, { body: uploadable, content_length: uploadable.size }]
       end
 
+      object(id).send(operation, s3_options_for(operation, options))
+
       Refile::File.new(self, id)
     end
 
@@ -145,11 +154,20 @@ def clear!(confirm = nil)
     # @return [Refile::Signature]
     def presign
       id = RandomHasher.new.hash
-      signature = @bucket.presigned_post(key: [*@prefix, id].join("/"))
+      signature = @bucket.presigned_post(s3_options_for(:presigned_post, key: [*@prefix, id].join("/")))
       signature.content_length_range(0..@max_size) if @max_size
       Signature.new(as: "file", id: id, url: signature.url.to_s, fields: signature.fields)
     end
 
+    def s3_options_for(operation, options = {})
+      keys = S3_AVAILABLE_OPTIONS.fetch(operation)
+      @s3_options.merge(options).select { |key, _| keys.include?(key) }
+    end
+
+    def upload_via_copy_operation?(uploadable)
+      uploadable.is_a?(Refile::File) and uploadable.backend.is_a?(S3) and uploadable.backend.access_key_id == access_key_id
+    end
+
     verify_id def object(id)
       @bucket.object([*@prefix, id].join("/"))
     end

spec/refile/s3_spec.rb

@@ -3,10 +3,106 @@
 
 WebMock.allow_net_connect!
 
-config = YAML.load_file("s3.yml").map { |k, v| [k.to_sym, v] }.to_h
+s3_config = YAML.load_file("s3.yml").map { |k, v| [k.to_sym, v] }.to_h
 
 RSpec.describe Refile::S3 do
+  let(:config) { s3_config }
   let(:backend) { Refile::S3.new(max_size: 100, **config) }
 
   it_behaves_like :backend
+
+  describe '@s3_options' do
+    let(:value) { backend.instance_variable_get(:@s3_options) }
+
+    it 'is initialized' do
+      %i(access_key_id secret_access_key region).each do |attribute|
+        expect(value[attribute]).to eq(config[attribute])
+      end
+    end
+
+    context 'given additional configuration options' do
+      let(:config) { { server_side_encryption: 'aes256' }.merge s3_config }
+
+      it 'is initialized' do
+        expect(value[:server_side_encryption]).to eq('aes256')
+      end
+    end
+  end
+
+  describe '.s3_options_for' do
+    let(:config) do
+      {
+        access_key_id: 'xyz',
+        secret_access_key: 'abcd1234',
+        region: 'sa-east-1',
+        bucket: 'my-bucket',
+        server_side_encryption: 'aes256',
+        storage_class: 'STANDARD'
+      }
+    end
+    let(:options) { {} }
+    let(:value) { backend.s3_options_for key, options }
+
+    describe 'given operation' do
+      context 'client' do
+        let(:key) { :client }
+
+        it 'returns valid options' do
+          expect(value).to eq(
+            access_key_id: 'xyz',
+            secret_access_key: 'abcd1234',
+            region: 'sa-east-1'
+          )
+        end
+      end
+
+      context 'copy_from' do
+        let(:key) { :copy_from }
+        let(:options) { { copy_source: 'xyz' } }
+
+        it 'returns valid options' do
+          expect(value).to eq(
+            copy_source: 'xyz',
+            server_side_encryption: 'aes256',
+            storage_class: 'STANDARD'
+          )
+        end
+      end
+
+      context 'presigned_post' do
+        let(:key) { :presigned_post }
+        let(:options) { { key: 'xyz' } }
+
+        it 'returns valid options' do
+          expect(value).to eq(
+            key: 'xyz',
+            server_side_encryption: 'aes256',
+            storage_class: 'STANDARD'
+          )
+        end
+      end
+
+      context 'put' do
+        let(:key) { :put }
+        let(:options) { { body: 'xyz', content_length: 3 } }
+
+        it 'returns valid options' do
+          expect(value).to eq(
+            body: 'xyz',
+            content_length: 3,
+            server_side_encryption: 'aes256',
+            storage_class: 'STANDARD'
+          )
+        end
+      end
+    end
+
+    context 'given an invalid operation' do
+      let(:key) { :invalid }
+
+      it 'raises an error' do
+        expect { value }.to raise_error(KeyError)
+      end
+    end
+  end
 end