aliyun-sdk 0.6.0 → 0.8.0

data/lib/aliyun/oss/struct.rb

@@ -74,6 +74,31 @@ module Aliyun
       end
     end
 
+    ##
+    # Bucket Versioning setting. See: {http://help.aliyun.com/document_detail/oss/product-documentation/function/versioning.html OSS Bucket versioning}
+    # Attributes:
+    # * status [String] the bucket versioning status, can be 'Enabled' and 'Suspended'
+    # @example Enable bucket versioning
+    #  bucket.versioning = BucketVersioning.new(:status => 'Enabled')
+    # @example Suspend bucket versioning
+    #  bucket.versioning = BucketVersioning.new(:status => 'Suspended')
+    class BucketVersioning < Common::Struct::Base
+      attrs :status
+    end
+    
+    ##
+    # Bucket Encryption setting. See: {http://help.aliyun.com/document_detail/oss/product-documentation/function/encryption.html OSS Bucket encryption}
+    # Attributes:
+    # * sse_algorithm [string] Indicates the default server-side encryption method
+    # * kms_master_key_id [string] Indicates the ID of CMK that is currently used.
+    class BucketEncryption < Common::Struct::Base
+      attrs :enable, :sse_algorithm, :kms_master_key_id
+
+      def enabled?
+        enable == true
+      end
+    end
+
     ##
     # Bucket website setting. See: {http://help.aliyun.com/document_detail/oss/product-documentation/function/host-static-website.html OSS Website hosting}
     # Attributes:
@@ -107,10 +132,10 @@ module Aliyun
     # * id [String] the unique id of a rule
     # * enabled [Boolean] whether to enable this rule
     # * prefix [String] the prefix objects to apply this rule
-    # * expiry [Date] or [Fixnum] the expire time of objects
+    # * expiry [Date] or [Integer] the expire time of objects
     #   * if expiry is a Date, it specifies the absolute date to
     #     expire objects
-    #   * if expiry is a Fixnum, it specifies the relative date to
+    #   * if expiry is a Integer, it specifies the relative date to
     #     expire objects: how many days after the object's last
     #     modification time to expire the object
     # @example Specify expiry as Date

data/lib/aliyun/oss/util.rb

@@ -93,6 +93,12 @@ module Aliyun
           end
         end
 
+        def ensure_bucket_name_valid(name)
+          unless (name =~ %r|^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$|)
+            fail ClientError, "The bucket name is invalid."
+          end
+        end  
+
       end # self
     end # Util
   end # OSS

data/lib/aliyun/sts/client.rb

@@ -25,7 +25,7 @@ module Aliyun
       # @param role [String] the role arn
       # @param session [String] the session name
       # @param policy [STS::Policy] the policy
-      # @param duration [Fixnum] the duration seconds for the
+      # @param duration [Integer] the duration seconds for the
       #  requested token
       # @return [STS::Token] the sts token
       def assume_role(role, session, policy = nil, duration = 3600)

data/lib/aliyun/sts/protocol.rb

@@ -27,7 +27,7 @@ module Aliyun
       # @param role [String] the role arn
       # @param session [String] the session name
       # @param policy [STS::Policy] the policy
-      # @param duration [Fixnum] the duration seconds for the
+      # @param duration [Integer] the duration seconds for the
       #  requested token
       # @return [STS::Token] the sts token
       def assume_role(role, session, policy = nil, duration = 3600)

data/lib/aliyun/version.rb

@@ -2,6 +2,6 @@
 
 module Aliyun
 
-    VERSION = "0.6.0"
+    VERSION = "0.8.0"
 
 end # Aliyun

data/spec/aliyun/oss/bucket_spec.rb

@@ -89,13 +89,32 @@ module Aliyun
             if opts.enabled?
               xml.LoggingEnabled {
                 xml.TargetBucket opts.target_bucket
-                xml.TargetPrefix opts.target_prefix
+                xml.TargetPrefix opts.target_prefix if opts.target_prefix
               }
             end
           }
         end.to_xml
       end
 
+      def mock_versioning(opts)
+        Nokogiri::XML::Builder.new do |xml|
+          xml.VersioningConfiguration {
+            xml.Status opts.status
+          }
+        end.to_xml
+      end
+
+      def mock_encryption(opts)
+        Nokogiri::XML::Builder.new do |xml|
+          xml.ServerSideEncryptionRule {
+            xml.ApplyServerSideEncryptionByDefault {
+              xml.SSEAlgorithm opts.sse_algorithm
+              xml.KMSMasterKeyID opts.kms_master_key_id if opts.kms_master_key_id
+            }
+          }
+        end.to_xml
+      end
+
       def mock_website(opts)
         Nokogiri::XML::Builder.new do |xml|
           xml.WebsiteConfiguration {
@@ -354,7 +373,7 @@ module Aliyun
         end
       end # delete bucket
 
-      context "acl, logging, website, referer, lifecycle" do
+      context "acl, logging, versioning, encryption, website, referer, lifecycle" do
         it "should update acl" do
           query = {'acl' => nil}
           stub_request(:put, request_path).with(:query => query)
@@ -392,6 +411,19 @@ module Aliyun
             .with(:query => query, :body => mock_logging(logging_opts))
         end
 
+        it "should enable logging without target prefix" do
+          query = {'logging' => nil}
+          stub_request(:put, request_path).with(:query => query)
+
+          logging_opts = BucketLogging.new(
+            :enable => true,
+            :target_bucket => 'target-bucket')
+          @protocol.put_bucket_logging(@bucket, logging_opts)
+
+          expect(WebMock).to have_requested(:put, request_path)
+            .with(:query => query, :body => mock_logging(logging_opts))
+        end
+
         it "should disable logging" do
           query = {'logging' => nil}
           stub_request(:put, request_path).with(:query => query)
@@ -420,6 +452,23 @@ module Aliyun
           expect(logging.to_s).to eq(logging_opts.to_s)
         end
 
+        it "should get logging without target-bucket" do
+          query = {'logging' => nil}
+          logging_opts = BucketLogging.new(
+            :enable => false,
+            :target_bucket => nil, :target_prefix => nil)
+
+          stub_request(:get, request_path)
+            .with(:query => query)
+            .to_return(:body => mock_logging(logging_opts))
+
+          logging = @protocol.get_bucket_logging(@bucket)
+
+          expect(WebMock).to have_requested(:get, request_path)
+            .with(:query => query, :body => nil)
+          expect(logging.to_s).to eq(logging_opts.to_s)
+        end
+
         it "should delete logging" do
           query = {'logging' => nil}
           stub_request(:delete, request_path).with(:query => query)
@@ -430,6 +479,18 @@ module Aliyun
             .with(:query => query, :body => nil)
         end
 
+        it "should raise Exception when enable logging" do
+          query = {'logging' => nil}
+          stub_request(:put, request_path).with(:query => query)
+
+          logging_opts = BucketLogging.new(
+            :enable => true,
+            :target_bucket => nil, :target_prefix => nil)
+          expect {
+            @protocol.put_bucket_logging(@bucket, logging_opts)
+          }.to raise_error(ClientError)
+        end
+
         it "should update website" do
           query = {'website' => nil}
           stub_request(:put, request_path).with(:query => query)
@@ -442,6 +503,18 @@ module Aliyun
             .with(:query => query, :body => mock_website(website_opts))
         end
 
+        it "should update website with index only" do
+          query = {'website' => nil}
+          stub_request(:put, request_path).with(:query => query)
+
+          website_opts = BucketWebsite.new(
+            :enable => true, :index => 'index.html', :error => nil)
+          @protocol.put_bucket_website(@bucket, website_opts)
+
+          expect(WebMock).to have_requested(:put, request_path)
+            .with(:query => query, :body => mock_website(website_opts))
+        end
+
         it "should get website" do
           query = {'website' => nil}
           website_opts = BucketWebsite.new(
@@ -468,6 +541,18 @@ module Aliyun
             .with(:query => query, :body => nil)
         end
 
+        it "should raise Exception when update website" do
+          query = {'website' => nil}
+          stub_request(:put, request_path).with(:query => query)
+
+          website_opts = BucketWebsite.new(
+            :enable => true, :index => nil)
+
+          expect {
+            @protocol.put_bucket_website(@bucket, website_opts)
+          }.to raise_error(ClientError)
+        end
+
         it "should update referer" do
           query = {'referer' => nil}
           stub_request(:put, request_path).with(:query => query)
@@ -541,6 +626,44 @@ module Aliyun
             .with(:query => query, :body => nil)
         end
 
+        it "should raise Exception when update lifecycle " do
+          query = {'lifecycle' => nil}
+          stub_request(:put, request_path).with(:query => query)
+
+          rules = (1..5).map do |i|
+            LifeCycleRule.new(
+              :id => i, :enable => i % 2 == 0, :prefix => "foo#{i}",
+              :expiry => 'invalid')
+          end
+ 
+          expect {
+            @protocol.put_bucket_lifecycle(@bucket, rules)
+          }.to raise_error(ClientError)
+        end        
+
+        it "should raise Exception when get lifecycle " do
+          query = {'lifecycle' => nil}
+          body = '<LifecycleConfiguration>
+                    <Rule>
+                      <ID>delete after one day</ID>
+                      <Prefix>logs/</Prefix>
+                      <Status>Enabled</Status>
+                      <Expiration>
+                        <Days>1</Days>
+                        <Date>2017-01-01T00:00:00.000Z</Date>
+                      </Expiration>
+                  </Rule>
+                </LifecycleConfiguration>'
+
+          stub_request(:get, request_path)
+            .with(:query => query)
+            .to_return(:body => body)
+ 
+          expect {
+            rules = @protocol.get_bucket_lifecycle(@bucket)
+          }.to raise_error(ClientError)
+        end        
+
         it "should set cors" do
           query = {'cors' => nil}
           stub_request(:put, request_path).with(:query => query)
@@ -558,6 +681,24 @@ module Aliyun
             .with(:query => query, :body => mock_cors(rules))
         end
 
+        it "should set cors with MaxAgeSeconds " do
+          query = {'cors' => nil}
+          stub_request(:put, request_path).with(:query => query)
+
+          rules = (1..5).map do |i|
+            CORSRule.new(
+              :allowed_origins => (1..3).map {|x| "origin-#{x}"},
+              :allowed_methods => ['PUT', 'GET'],
+              :allowed_headers => (1..3).map {|x| "header-#{x}"},
+              :expose_headers => (1..3).map {|x| "header-#{x}"},
+              :max_age_seconds => 5)
+          end
+          @protocol.set_bucket_cors(@bucket, rules)
+
+          expect(WebMock).to have_requested(:put, request_path)
+            .with(:query => query, :body => mock_cors(rules))
+        end
+
         it "should get cors" do
           query = {'cors' => nil}
           return_rules = (1..5).map do |i|

data/spec/aliyun/oss/client/bucket_spec.rb

@@ -156,6 +156,350 @@ module Aliyun
             .with(:query => query, :body => nil)
         end
 
+        it "should set logging setting" do
+          query = {'logging' => nil}
+
+          body = Nokogiri::XML::Builder.new do |xml|
+            xml.BucketLoggingStatus {
+              xml.LoggingEnabled {
+                xml.TargetBucket 'target-bucket'
+              }
+            }
+            end.to_xml
+
+          stub_request(:put, bucket_url).with(:query => query)
+
+          @bucket.logging = BucketLogging.new(:enable => true, :target_bucket => 'target-bucket')
+
+          expect(WebMock).to have_requested(:put, bucket_url)
+            .with(:query => query, :body => body)
+        end
+
+        it "should get logging setting" do
+          query = {'logging' => nil}
+
+          retbody = Nokogiri::XML::Builder.new do |xml|
+            xml.BucketLoggingStatus {
+              xml.LoggingEnabled {
+                xml.TargetBucket 'target-bucket'
+                xml.TargetPrefix 'target-prefix'
+              }
+            }
+            end.to_xml
+
+          stub_request(:get, bucket_url)
+            .with(:query => query)
+            .to_return(status: 200, :body => retbody)
+
+          logging = @bucket.logging
+
+          expect(WebMock).to have_requested(:get, bucket_url)
+            .with(:query => query, :body => nil)
+          expect(logging.enable).to eq(true)
+          expect(logging.target_bucket).to eq('target-bucket')
+
+        end
+
+        it "should set webseit" do
+          query = {'website' => nil}
+
+          body = Nokogiri::XML::Builder.new do |xml|
+            xml.WebsiteConfiguration {
+              xml.IndexDocument {
+                xml.Suffix 'index.html'
+              }
+            }
+            end.to_xml
+
+          stub_request(:put, bucket_url)
+            .with(:query => query)
+            .to_return(status: 200, :body => nil)
+
+          @bucket.website = BucketWebsite.new(:enable => true, :index => 'index.html')
+
+          expect(WebMock).to have_requested(:put, bucket_url)
+            .with(:query => query, :body => body)
+        end
+
+        it "should delete webseit" do
+          query = {'website' => nil}
+
+          stub_request(:delete, bucket_url)
+            .with(:query => query)
+            .to_return(status: 204, :body => nil)
+
+          @bucket.website = BucketWebsite.new(:enable => false)
+
+          expect(WebMock).to have_requested(:delete, bucket_url)
+            .with(:query => query, :body => nil)
+        end
+
+        it "should get webseit" do
+          query = {'website' => nil}
+
+          body = Nokogiri::XML::Builder.new do |xml|
+            xml.WebsiteConfiguration {
+              xml.IndexDocument {
+                xml.Suffix 'index.html'
+              }
+              xml.ErrorDocument {
+                xml.Key 'error.html'
+              }
+            }
+            end.to_xml
+
+          stub_request(:get, bucket_url)
+            .with(:query => query)
+            .to_return(status: 200, :body => body)
+
+          website = @bucket.website
+
+          expect(WebMock).to have_requested(:get, bucket_url)
+            .with(:query => query, :body => nil)
+
+          expect(website.enable).to eq(true)
+          expect(website.index).to eq('index.html')
+          expect(website.error).to eq('error.html')
+        end
+
+        it "should set referer" do
+          query = {'referer' => nil}
+
+          body = Nokogiri::XML::Builder.new do |xml|
+            xml.RefererConfiguration {
+              xml.AllowEmptyReferer 'true'
+              xml.RefererList {
+                xml.Referer 'http://www.aliyun.com'
+              }
+            }
+            end.to_xml
+
+          stub_request(:put, bucket_url)
+            .with(:query => query)
+            .to_return(status: 200, :body => nil)
+
+          @bucket.referer = BucketReferer.new(:allow_empty => true, :whitelist => ['http://www.aliyun.com'])
+
+          expect(WebMock).to have_requested(:put, bucket_url)
+            .with(:query => query, :body => body)
+        end
+
+        it "should get referer" do
+          query = {'referer' => nil}
+
+          body = Nokogiri::XML::Builder.new do |xml|
+            xml.RefererConfiguration {
+              xml.AllowEmptyReferer 'true'
+              xml.RefererList {
+                xml.Referer 'http://www.aliyun.com'
+              }
+            }
+            end.to_xml
+
+          stub_request(:get, bucket_url)
+            .with(:query => query)
+            .to_return(status: 200, :body => body)
+
+          referer = @bucket.referer
+
+          expect(WebMock).to have_requested(:get, bucket_url)
+            .with(:query => query, :body => nil)
+
+          expect(referer.allow_empty).to eq(true)
+          expect(referer.whitelist).to eq(['http://www.aliyun.com'])
+        end
+
+        it "should set cors" do
+          query = {'cors' => nil}
+
+          body = Nokogiri::XML::Builder.new do |xml|
+            xml.CORSConfiguration {
+              xml.CORSRule {
+                xml.AllowedOrigin '*'
+                xml.AllowedMethod 'PUT'
+                xml.AllowedHeader 'Authorization'
+              }
+            }
+            end.to_xml
+
+          stub_request(:put, bucket_url)
+            .with(:query => query)
+            .to_return(status: 200, :body => nil)
+
+          rules = [
+            CORSRule.new(
+              :allowed_origins => ['*'],
+              :allowed_methods => ['PUT'],
+              :allowed_headers => ['Authorization'],
+              :expose_headers =>[])
+          ]
+
+          @bucket.cors = rules
+
+          expect(WebMock).to have_requested(:put, bucket_url)
+            .with(:query => query, :body => body)
+        end
+
+        it "should delete cors" do
+          query = {'cors' => nil}
+
+          stub_request(:delete, bucket_url)
+            .with(:query => query)
+            .to_return(status: 204, :body => nil)
+
+          @bucket.cors = []
+
+          expect(WebMock).to have_requested(:delete, bucket_url)
+            .with(:query => query, :body => nil)
+        end
+
+        it "should get cors" do
+          query = {'cors' => nil}
+
+          body = Nokogiri::XML::Builder.new do |xml|
+            xml.CORSConfiguration {
+              xml.CORSRule {
+                xml.AllowedOrigin '*'
+                xml.AllowedMethod 'PUT'
+                xml.AllowedHeader 'Authorization'
+              }
+            }
+            end.to_xml
+
+          stub_request(:get, bucket_url)
+            .with(:query => query)
+            .to_return(status: 200, :body => body)
+
+          cors = @bucket.cors
+
+          expect(WebMock).to have_requested(:get, bucket_url)
+            .with(:query => query, :body => nil)
+        end
+
+		it "should set versioning" do
+          query = {'versioning' => nil}
+
+          body = Nokogiri::XML::Builder.new do |xml|
+            xml.VersioningConfiguration {
+              xml.Status 'Enabled'
+            }
+            end.to_xml
+
+          stub_request(:put, bucket_url)
+            .with(:query => query)
+            .to_return(status: 200, :body => nil)
+
+          @bucket.versioning = BucketVersioning.new(:status => 'Enabled')
+
+          expect(WebMock).to have_requested(:put, bucket_url)
+            .with(:query => query, :body => body)
+        end
+
+		it "should get versioning" do
+          query = {'versioning' => nil}
+
+          body = Nokogiri::XML::Builder.new do |xml|
+            xml.VersioningConfiguration {
+              xml.Status 'Enabled'
+            }
+            end.to_xml
+
+          stub_request(:get, bucket_url)
+            .with(:query => query)
+            .to_return(status: 200, :body => body)
+
+          ret = @bucket.versioning
+
+          expect(WebMock).to have_requested(:get, bucket_url)
+            .with(:query => query, :body => nil)
+
+          expect(ret.status).to eq('Enabled')
+        end
+
+		it "should set encryption with aes256" do
+          query = {'encryption' => nil}
+
+          body = Nokogiri::XML::Builder.new do |xml|
+            xml.ServerSideEncryptionRule {
+              xml.ApplyServerSideEncryptionByDefault {
+                xml.SSEAlgorithm 'AES256'
+              }
+            }
+            end.to_xml
+
+          stub_request(:put, bucket_url)
+            .with(:query => query)
+            .to_return(status: 200, :body => nil)
+
+          @bucket.encryption = BucketEncryption.new(:enable => true, :sse_algorithm => 'AES256')
+
+          expect(WebMock).to have_requested(:put, bucket_url)
+            .with(:query => query, :body => body)
+        end
+
+		it "should set encryption with KMS" do
+          query = {'encryption' => nil}
+
+          body = Nokogiri::XML::Builder.new do |xml|
+            xml.ServerSideEncryptionRule {
+              xml.ApplyServerSideEncryptionByDefault {
+                xml.SSEAlgorithm 'KMS'
+                xml.KMSMasterKeyID 'kms-id'
+              }
+            }
+            end.to_xml
+
+          stub_request(:put, bucket_url)
+            .with(:query => query)
+            .to_return(status: 200, :body => nil)
+
+          @bucket.encryption = BucketEncryption.new(
+			:enable => true, 
+			:sse_algorithm => 'KMS', 
+			:kms_master_key_id => 'kms-id')
+
+          expect(WebMock).to have_requested(:put, bucket_url)
+            .with(:query => query, :body => body)
+        end
+
+		it "should get encryption" do
+          query = {'encryption' => nil}
+
+          body = Nokogiri::XML::Builder.new do |xml|
+            xml.ServerSideEncryptionRule {
+              xml.ApplyServerSideEncryptionByDefault {
+                xml.SSEAlgorithm 'KMS'
+                xml.KMSMasterKeyID 'kms-id'
+              }
+            }
+            end.to_xml
+
+          stub_request(:get, bucket_url)
+            .with(:query => query)
+            .to_return(status: 200, :body => body)
+
+          ret = @bucket.encryption
+
+          expect(WebMock).to have_requested(:get, bucket_url)
+            .with(:query => query, :body => nil)
+
+          expect(ret.sse_algorithm).to eq('KMS')
+          expect(ret.kms_master_key_id).to eq('kms-id')
+        end
+
+		it "should delete encryption" do
+          query = {'encryption' => nil}
+
+          stub_request(:delete, bucket_url)
+            .with(:query => query)
+            .to_return(status: 204, :body => nil)
+
+          @bucket.encryption = BucketEncryption.new(:enable => false)
+
+          expect(WebMock).to have_requested(:delete, bucket_url)
+            .with(:query => query, :body => nil)
+        end
+
         it "should get bucket url" do
           expect(@bucket.bucket_url)
             .to eq('http://rubysdk-bucket.oss-cn-hangzhou.aliyuncs.com/')
@@ -467,29 +811,55 @@ module Aliyun
           expect(signature).to eq(sig)
         end
 
-        it "should get object url with STS" do
-          sts_bucket = Client.new(
-            :endpoint => @endpoint,
-            :access_key_id => 'xxx',
-            :access_key_secret => 'yyy',
-            :sts_token => 'zzz').get_bucket(@bucket_name)
-
-          object_url = 'http://rubysdk-bucket.oss-cn-hangzhou.aliyuncs.com/yeah'
-
-          url = sts_bucket.object_url('yeah')
-          path = url[0, url.index('?')]
-          expect(path).to eq(object_url)
-
-          query = {}
-          url[url.index('?') + 1, url.size].split('&')
-            .each { |s| k, v = s.split('='); query[k] = v }
-
-          expect(query.key?('Expires')).to be true
-          expect(query.key?('Signature')).to be true
-          expect(query['OSSAccessKeyId']).to eq('xxx')
-          expect(query['security-token']).to eq('zzz')
+        context 'should use STS' do
+          it "get object url" do
+            sts_bucket = Client.new(
+              :endpoint => @endpoint,
+              :access_key_id => 'xxx',
+              :access_key_secret => 'yyy',
+              :sts_token => 'zzz').get_bucket(@bucket_name)
+
+            object_url = 'http://rubysdk-bucket.oss-cn-hangzhou.aliyuncs.com/yeah'
+
+            url = sts_bucket.object_url('yeah')
+            path = url[0, url.index('?')]
+            expect(path).to eq(object_url)
+
+            query = {}
+            url[url.index('?') + 1, url.size].split('&')
+              .each { |s| k, v = s.split('='); query[k] = v }
+
+            expect(query.key?('Expires')).to be true
+            expect(query.key?('Signature')).to be true
+            expect(query['OSSAccessKeyId']).to eq('xxx')
+            expect(query['security-token']).to eq('zzz')
+          end
+
+          it "get object url with query string" do
+            sts_bucket = Client.new(
+              :endpoint => @endpoint,
+              :access_key_id => 'xxx',
+              :access_key_secret => 'yyy',
+              :sts_token => 'zzz').get_bucket(@bucket_name)
+
+            param = {
+              'x-oss-process' => 'image/resize,m_fill,h_100,w_100',
+            }  
+            url = sts_bucket.object_url('ico.png', true, 60, param)
+            path = url[0, url.index('?')]
+            expect(path).to eq('http://rubysdk-bucket.oss-cn-hangzhou.aliyuncs.com/ico.png')
+
+            query = {}
+            url[url.index('?') + 1, url.size].split('&')
+              .each { |s| k, v = s.split('='); query[k] = v }
+
+            expect(query.key?('Expires')).to be true
+            expect(query.key?('Signature')).to be true
+            expect(query['OSSAccessKeyId']).to eq('xxx')
+            expect(query['security-token']).to eq('zzz')
+            expect(query['x-oss-process']).to eq('image%2Fresize%2Cm_fill%2Ch_100%2Cw_100')
+          end
         end
-
       end # object operations
 
       context "multipart operations" do