aliyun-oss-sdk 0.0.3 → 0.1.0

data/lib/aliyun/oss/struct/bucket.rb

@@ -0,0 +1,252 @@
+module Aliyun
+  module Oss
+    module Struct
+      class Bucket < Base
+        # Bucket Name
+        attr_accessor :name
+
+        # Bucket Location
+        attr_accessor :location
+
+        # Createion date of Bucket
+        attr_accessor :creation_date
+
+        # reference to client
+        attr_accessor :client
+
+        # Get the location
+        #
+        # @return [String]
+        #
+        # @see Client#bucket_get_location
+        def location!
+          result = client.bucket_get_location.parsed_response
+          Utils.dig_value(result, 'LocationConstraint', '__content__')
+        end
+
+        # Get Logging configration for bucket
+        #
+        # return [true]
+        #
+        # @see Client#bucket_get_logging
+        def logging!
+          result = client.bucket_get_logging.parsed_response
+          Struct::Logging.new(Utils.dig_value(result, 'BucketLoggingStatus'))
+        end
+
+        # Used to enable access logging.
+        #
+        # @param (see #bucket_enable_logging)
+        #
+        # @return [true]
+        #
+        # @see Client#bucket_enable_logging
+        def enable_logging(*args)
+          !!client.bucket_enable_logging(*args)
+        end
+
+        # Used to disable access logging.
+        #
+        # @param (see #bucket_disable_logging)
+        #
+        # @return [true]
+        #
+        # @see Client#bucket_disable_logging
+        def disable_logging
+          !!client.bucket_disable_logging
+        end
+
+        # Get the acl
+        #
+        # @return [String]
+        #
+        # @see Client#bucket_get_acl
+        def acl!
+          result = client.bucket_get_acl.parsed_response
+          acl_keys = %w(AccessControlPolicy AccessControlList Grant)
+          Utils.dig_value(result, *acl_keys)
+        end
+
+        # Set ACL for bucket
+        #
+        # @param (see #bucket_set_acl)
+        #
+        # @raise (see #bucket_set_acl)
+        #
+        # @return [true]
+        #
+        # @see Client#bucket_set_acl
+        def set_acl(*args)
+          !!client.bucket_set_acl(*args)
+        end
+
+        # Get the CORS
+        #
+        # @return [Array<Aliyun::Oss::Struct::Cors>]
+        #
+        # @see Client#bucket_get_cors
+        def cors!
+          result = client.bucket_get_cors.parsed_response
+          cors_keys = %w(CORSConfiguration CORSRule)
+          Utils.wrap(Utils.dig_value(result, *cors_keys)).map do |cors|
+            Struct::Cors.new(cors)
+          end
+        end
+
+        # Set CORS for bucket
+        #
+        # @see (see #bucket_enable_cors)
+        #
+        # @param (see #bucket_enable_cors)
+        #
+        # @raise (see #bucket_enable_cors)
+        #
+        # @return [true]
+        #
+        # @see Client#bucket_enable_cors
+        def enable_cors(*args)
+          !!client.bucket_enable_cors(*args)
+        end
+
+        # Disable CORS for bucket
+        #
+        # @see (see #bucket_disable_cors)
+        #
+        # @raise (see #bucket_disable_cors)
+        #
+        # @return [true]
+        #
+        # @see Client#bucket_disable_cors
+        def disable_cors
+          !!client.bucket_disable_cors
+        end
+
+        # Get the website configuration
+        #
+        # @return [Aliyun::Oss::Rule::Website]
+        #
+        # @see Client#bucket_get_website
+        def website!
+          result = client.bucket_get_website.parsed_response
+          suffix_keys = %w(WebsiteConfiguration IndexDocument Suffix)
+          error_keys = %w(WebsiteConfiguration ErrorDocument Key)
+          Aliyun::Oss::Struct::Website.new(
+            suffix: Utils.dig_value(result, *suffix_keys),
+            error_key: Utils.dig_value(result, *error_keys)
+          )
+        end
+
+        # Used to enable static website hosted mode.
+        #
+        # @see (see #bucket_enable_website)
+        #
+        # @param (see #bucket_enable_website)
+        #
+        # @raise (see #bucket_enable_website)
+        #
+        # @return [true]
+        #
+        # @see Client#bucket_enable_website
+        def enable_website(*args)
+          !!client.bucket_enable_website(*args)
+        end
+
+        # Used to disable website hostted mode.
+        #
+        # @see (see #bucket_disable_website)
+        #
+        # @raise (see #bucket_disable_website)
+        #
+        # @return [Response]
+        #
+        # @see Client#bucket_disable_website
+        def disable_website
+          !!client.bucket_disable_website
+        end
+
+        # Get the referer configuration
+        #
+        # @return [Aliyun::Oss::Struct::Referer]
+        #
+        # @see Client#bucket_get_referer
+        def referer!
+          result = client.bucket_get_referer.parsed_response
+          allow_empty = %w(RefererConfiguration AllowEmptyReferer)
+          referers = %w(RefererConfiguration RefererList Referer)
+          Aliyun::Oss::Struct::Referer.new(
+            allow_empty: Utils.dig_value(result, *allow_empty),
+            referers: Utils.dig_value(result, *referers)
+          )
+        end
+
+        # Used to set referer for bucket.
+        #
+        # @see (see #bucket_set_referer)
+        #
+        # @param (see #bucket_set_referer)
+        #
+        # @raise (see #bucket_set_referer)
+        #
+        # @return [true]
+        #
+        # @see Client#set_referer
+        def set_referer(*args)
+          !!client.bucket_set_referer(*args)
+        end
+
+        # Get the lifecycle configuration
+        #
+        # @return [Array<Aliyun::Oss::Struct::Lifecycle?]
+        #
+        # @see Client#bucket_get_lifecycle
+        def lifecycle!
+          result = client.bucket_get_lifecycle.parsed_response
+          lifecycle_keys = %w(LifecycleConfiguration Rule)
+          Utils.wrap(Utils.dig_value(result, *lifecycle_keys)).map do |lifecycle|
+            Struct::LifeCycle.new(lifecycle)
+          end
+        end
+
+        # Used to enable and set lifecycle for bucket
+        #
+        # @param (see #bucket_enable_lifecycle)
+        #
+        # @raise (see #bucket_enable_lifecycle)
+        #
+        # @return [true]
+        #
+        # @see Client#bucket_enable_lifecycle
+        def enable_lifecycle(*args)
+          !!client.bucket_enable_lifecycle(*args)
+        end
+
+        # Used to disable lifecycle for bucket
+        #
+        # @raise (see #bucket_disable_lifecycle)
+        #
+        # @return [true]
+        #
+        # @see Client#bucket_disable_lifecycle
+        def disable_lifecycle
+          !!client.bucket_disable_lifecycle
+        end
+
+        # OPTIONS Object
+        #
+        # @see (see #bucket_preflight)
+        #
+        # @param (see #bucket_preflight)
+        #
+        # @raise (see #bucket_preflight)
+        #
+        # @return [true]
+        #
+        # @see Client#bucket_preflight
+        def preflight(*args)
+          !!client.bucket_preflight(*args)
+        end
+        alias_method :options, :preflight
+      end
+    end
+  end
+end

data/lib/aliyun/oss/struct/cors.rb

@@ -0,0 +1,65 @@
+module Aliyun
+  module Oss
+    module Struct
+      class Cors < Base
+        ACCESSPTED_METHODS = %w(GET PUT DELETE POST HEAD)
+
+        # Set allowed origins. [Array]
+        attr_accessor :allowed_origin
+
+        # Set allowed methods. [Array]
+        attr_accessor :allowed_method
+
+        # Set allowed headers used in preflight (see #bucket_preflight). [Array]
+        attr_accessor :allowed_header
+
+        # Set allowed used response headers for user. [Array]
+        attr_accessor :expose_header
+
+        # Specifies cache time the browser to pre-fetch a particular resource request in seconds. [Integer]
+        attr_accessor :max_age_seconds
+
+        def allowed_origin=(allowed_origin)
+          @allowed_origin = Utils.wrap(allowed_origin)
+        end
+
+        def allowed_method=(allowed_method)
+          @allowed_method = Utils.wrap(allowed_method)
+                            .map(&:upcase)
+                            .select { |method| ACCESSPTED_METHODS.include?(method.to_s) }
+        end
+
+        def allowed_header=(allowed_header)
+          @allowed_header = Utils.wrap(allowed_header)
+        end
+
+        def expose_header=(expose_header)
+          @expose_header = Utils.wrap(expose_header)
+        end
+
+        def to_hash
+          return {} unless valid?
+
+          attrs = {
+            'AllowedOrigin' => allowed_origin,
+            'AllowedMethod' => allowed_method
+          }
+          attrs.merge!('AllowedHeader' => allowed_header) if value_present?(allowed_header)
+          attrs.merge!('EsposeHeader' => expose_header) if value_present?(expose_header)
+          attrs.merge!('MaxAgeSeconds' => max_age_seconds) if max_age_seconds
+          attrs
+        end
+
+        def valid?
+          value_present?(allowed_origin) && value_present?(allowed_method)
+        end
+
+        private
+
+        def value_present?(value)
+          value && !value.empty?
+        end
+      end
+    end
+  end
+end

data/lib/aliyun/oss/struct/lifecycle.rb

@@ -0,0 +1,73 @@
+module Aliyun
+  module Oss
+    module Struct
+      class LifeCycle < Base
+        # Rule ID, auto set when not set. [String]
+        attr_accessor :id
+
+        # Used for filter objects. [String]
+        attr_accessor :prefix
+
+        # Used for set rule status. [Boolean]
+        attr_accessor :enabled
+
+        # Set auto delete objects after days since last modified, at least exist one with date [Integer]
+        attr_accessor :days
+
+        # Set auto auto delete object at given time, at least exist one with days, [Time]
+        attr_accessor :date
+
+        def status=(status)
+          @enabled = (status == 'Enabled')
+        end
+
+        def date=(date)
+          @date = date.is_a?(String) ? Time.parse(date) : date
+        end
+
+        def days=(days)
+          @days = days.to_i
+        end
+
+        def to_hash
+          return {} unless valid?
+
+          {
+            'ID' => id || '',
+            'Prefix' => prefix,
+            'Status' => status,
+            'Expiration' => expiration
+          }
+        end
+
+        def expiration=(expiration)
+          return unless expiration.is_a?(Hash)
+
+          if expiration.key?('Days')
+            self.days = expiration['Days']
+          elsif expiration.key?('Date')
+            self.date = expiration['Date']
+          end
+        end
+
+        def valid?
+          prefix && (days || date)
+        end
+
+        private
+
+        def status
+          enabled ? 'Enabled' : 'Disabled'
+        end
+
+        def expiration
+          if date && date.is_a?(Time)
+            { 'Date' => date.utc.strftime('%Y-%m-%dT00:00:00.000Z') }
+          elsif days && days.is_a?(Integer)
+            { 'Days' => days.to_i }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aliyun/oss/struct/logging.rb

@@ -0,0 +1,33 @@
+module Aliyun
+  module Oss
+    module Struct
+      class Logging < Base
+        # Container for logging information. This element and its children are present when logging is enabled; otherwise, this element and its children are absent.
+        attr_accessor :logging_enabled
+
+        # This element specifies the bucket where server access logs will be delivered.
+        attr_accessor :target_bucket
+
+        # Specifies the prefix for the keys that the log files are being stored for.
+        attr_accessor :target_prefix
+
+        def initialize(attributes = {})
+          @logging_enabled = false
+          super
+        end
+
+        def logging_enabled=(logging_enabled)
+          return @logging_enabled = false unless logging_enabled.is_a?(Hash)
+
+          if logging_enabled.key?('TargetBucket')
+            @target_bucket = logging_enabled['TargetBucket']
+          end
+          if logging_enabled.key?('TargetPrefix')
+            @target_prefix = logging_enabled['TargetPrefix']
+          end
+          @logging_enabled = true
+        end
+      end
+    end
+  end
+end

data/lib/aliyun/oss/struct/multipart.rb

@@ -0,0 +1,101 @@
+module Aliyun
+  module Oss
+    module Struct
+      class Multipart < Base
+        # UUID for the Multipart Upload Event
+        attr_accessor :upload_id
+
+        # Object name of the Multipart Upload Event
+        attr_accessor :key
+
+        # Bucket name of the Multipart Upload Event
+        attr_accessor :bucket
+
+        # Initiation time of the Multipart Upload Event
+        attr_accessor :initiated
+
+        # reference to client
+        attr_accessor :client
+
+        def initiated=(initiated)
+          @initiated = Time.parse(initiated)
+        end
+
+        # Upload part to Multipart Upload Event
+        #
+        # @param number [Integer] the part number, Range in 1~10000.
+        # @param file [File, bin data] the upload data
+        #
+        # @raise (see #bucket_multipart_upload)
+        #
+        # @return [true]
+        def upload(*args)
+          !!client.bucket_multipart_upload(*args.unshift(upload_id, key))
+        end
+
+        # Copy exsting object to Multipart Upload Event
+        #
+        # @param number [Integer] the part number, Range in 1~10000.
+        # @param options [Hash] options
+        # @option (see #bucket_multipart_copy_upload)
+        #
+        # @raise (see #bucket_multipart_copy_upload)
+        #
+        # @return [true]
+        #
+        # @see Client#bucket_list_parts
+        def copy(*args)
+          !!client.bucket_multipart_copy_upload(*args.unshift(upload_id, key))
+        end
+
+        # List uploaded parts for the Multipart Upload Event
+        #
+        # @param options [Hash] options
+        # @option (see #bucket_list_parts)
+        #
+        # @raise (see #bucket_list_parts)
+        #
+        # @return [Array<Aliyun::Oss::Struct::Part>]
+        #
+        # @see Client#bucket_list_parts
+        def list_parts(options = {})
+          result = client.bucket_list_parts(upload_id, key, options)
+                   .parsed_response
+
+          parts_keys = %w(ListPartsResult Part)
+          Utils.wrap(Utils.dig_value(result, *parts_keys)).map do |part|
+            Struct::Part.new(part)
+          end
+        end
+
+        # Complete Multipart Upload Event
+        #
+        # @param parts [Array<Multipart:Part>] parts
+        #
+        # @raise (see #bucket_complete_multipart)
+        #
+        # @return [Struct::Object]
+        #
+        # @see Client#bucket_complete_multipart
+        def complete(parts = [])
+          resp = client.bucket_complete_multipart(upload_id, key, parts)
+          keys = %w(CompleteMultipartUploadResult)
+          Struct::Object.new(
+            Utils.dig_value(resp.parsed_response, *keys).merge(client: client)
+          )
+        end
+
+        # Abort Multipart Upload Event
+        #
+        # @raise (see #bucket_abort_multipart)
+        #
+        # @return [true]
+        #
+        # @see Client#bucket_abort_multipart
+        def abort
+          !!client.bucket_abort_multipart(upload_id, key)
+        end
+      end
+    end
+  end
+end