s3 0.2.0

data/lib/stree/connection.rb

@@ -0,0 +1,199 @@
+module Stree
+
+  # Class responsible for handling connections to amazon hosts
+  class Connection
+    include Parser
+
+    attr_accessor :access_key_id, :secret_access_key, :use_ssl, :timeout, :debug
+    alias :use_ssl? :use_ssl
+
+    # ==== Parameters:
+    # +options+:: Hash of options
+    #
+    # ==== Options:
+    # +access_key_id+:: access key id
+    # +secret_access_key+:: secret access key
+    # +use_ssl+:: optional, defaults to false
+    # +debug+:: optional, defaults to false
+    # +timeout+:: optional, for Net::HTTP
+    def initialize(options = {})
+      @access_key_id = options[:access_key_id]
+      @secret_access_key = options[:secret_access_key]
+      @use_ssl = options[:use_ssl] || false
+      @debug = options[:debug]
+      @timeout = options[:timeout]
+    end
+
+    # Makes request with given HTTP method, sets missing parameters,
+    # adds signature to request header and returns response object
+    # (Net::HTTPResponse)
+    #
+    # ==== Parameters:
+    # +method+:: HTTP Method symbol, can be :get, :put, :delete
+    # +options+:: hash of options
+    #
+    # ==== Options:
+    # +host+:: hostname to connecto to, optional, defaults to s3.amazonaws.com[s3.amazonaws.com]
+    # +path+:: path to send request to, required, throws ArgumentError if not given
+    # +body+:: request body, only meaningful for :put request
+    # +params+:: parameters to add to query string for request, can be String or Hash
+    # +headers+:: Hash of headers fields to add to request header
+    #
+    # ==== Returns:
+    # Net::HTTPResponse object -- response from remote server
+    def request(method, options)
+      host = options[:host] || HOST
+      path = options[:path] or raise ArgumentError.new("no path given")
+      body = options[:body]
+      params = options[:params]
+      headers = options[:headers]
+
+      if params
+        params = params.is_a?(String) ? params : self.class.parse_params(params)
+        path << "?#{params}"
+      end
+
+      path = URI.escape(path)
+      request = request_class(method).new(path)
+
+      headers = self.class.parse_headers(headers)
+      headers.each do |key, value|
+        request[key] = value
+      end
+
+      request.body = body
+
+      send_request(host, request)
+    end
+
+    # Helper function to parser parameters and create single string of params
+    # added to questy string
+    #
+    # ==== Parameters:
+    # +params+: Hash of parameters if form <tt>key => value|nil</tt>
+    #
+    # ==== Returns:
+    # String -- containing all parameters joined in one params string,
+    # i.e. <tt>param1=val&param2&param3=0</tt>
+    def self.parse_params(params)
+      interesting_keys = [:max_keys, :prefix, :marker, :delimiter, :location]
+
+      result = []
+      params.each do |key, value|
+        if interesting_keys.include?(key)
+          parsed_key = key.to_s.gsub("_", "-")
+          case value
+          when nil
+            result << parsed_key
+          else
+            result << "#{parsed_key}=#{value}"
+          end
+        end
+      end
+      result.join("&")
+    end
+
+    # Helper function to change headers from symbols, to in correct
+    # form (i.e. with '-' instead of '_')
+    #
+    # ==== Parameters:
+    # +headers+:: Hash of pairs <tt>headername => value</tt>,
+    #             where value can be Range (for Range header) or any other
+    #             value which can be translated to string
+    #
+    # ==== Returns:
+    # Hash of headers translated from symbol to string,
+    # containing only interesting headers
+    def self.parse_headers(headers)
+      interesting_keys = [:content_type, :x_amz_acl, :range,
+                          :if_modified_since, :if_unmodified_since,
+                          :if_match, :if_none_match,
+                          :content_disposition, :content_encoding,
+                          :x_amz_copy_source, :x_amz_metadata_directive,
+                          :x_amz_copy_source_if_match,
+                          :x_amz_copy_source_if_none_match,
+                          :x_amz_copy_source_if_unmodified_since,
+                          :x_amz_copy_source_if_modified_since]
+
+      parsed_headers = {}
+      if headers
+        headers.each do |key, value|
+          if interesting_keys.include?(key)
+            parsed_key = key.to_s.gsub("_", "-")
+            parsed_value = value
+            case value
+            when Range
+              parsed_value = "bytes=#{value.first}-#{value.last}"
+            end
+            parsed_headers[parsed_key] = parsed_value
+          end
+        end
+      end
+      parsed_headers
+    end
+
+    private
+
+    def request_class(method)
+      case method
+      when :get
+        request_class = Net::HTTP::Get
+      when :put
+        request_class = Net::HTTP::Put
+      when :delete
+        request_class = Net::HTTP::Delete
+      end
+    end
+
+    def port
+      use_ssl ? 443 : 80
+    end
+
+    def http(host)
+      http = Net::HTTP.new(host, port)
+      http.set_debug_output(STDOUT) if @debug
+      http.use_ssl = @use_ssl
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE if @use_ssl
+      http.read_timeout = @timeout if @timeout
+      http
+    end
+
+    def send_request(host, request)
+      response = http(host).start do |http|
+        host = http.address
+
+        request['Date'] ||= Time.now.httpdate
+
+        if request.body
+          request["Content-Type"] ||= "application/octet-stream"
+          request["Content-MD5"] = Base64.encode64(Digest::MD5.digest(request.body)).chomp
+        end
+
+        request["Authorization"] = Signature.generate(:host => host,
+                                                          :request => request,
+                                                          :access_key_id => access_key_id,
+                                                          :secret_access_key => secret_access_key)
+        http.request(request)
+      end
+
+      handle_response(response)
+    end
+
+    def handle_response(response)
+      case response.code.to_i
+      when 200...300
+        response
+      when 300...600
+        if response.body.nil? || response.body.empty?
+          raise Error::ResponseError.new(nil, response)
+        else
+          code, message = parse_error(response.body)
+          raise Error::ResponseError.exception(code).new(message, response)
+        end
+      else
+        raise(ConnectionError.new(response, "Unknown response code: #{response.code}"))
+      end
+      response
+    end
+  end
+end

data/lib/stree/exceptions.rb

@@ -0,0 +1,108 @@
+module Stree
+  module Error
+
+    # All responses with a code between 300 and 599 that contain an
+    # <Error></Error> body are wrapped in an ErrorResponse which
+    # contains an Error object. This Error class generates a custom
+    # exception with the name of the xml Error and its message. All
+    # such runtime generated exception classes descend from
+    # ResponseError and contain the ErrorResponse object so that all
+    # code that makes a request can rescue ResponseError and get
+    # access to the ErrorResponse.
+    class ResponseError < StandardError
+      attr_reader :response
+
+      # ==== Parameters:
+      # +message+:: what went wrong
+      # +response+:: Net::HTTPResponse object or nil
+      def initialize(message, response)
+        @response = response
+        super(message)
+      end
+
+      # Factory for all other Exception classes in module, each for every
+      # error response available from AmazonAWS
+      #
+      # ==== Parameters:
+      # +code+:: code name of exception
+      #
+      # ==== Returns:
+      # Descendant of ResponseError suitable for that exception code or ResponseError class
+      # if no class found
+      def self.exception(code)
+        Stree::Error.const_get(code)
+      rescue NameError
+        ResponseError
+      end
+    end
+
+    #:stopdoc:
+
+    class AccessDenied < ResponseError; end
+    class AccountProblem < ResponseError; end
+    class AmbiguousGrantByEmailAddress < ResponseError; end
+    class BadDigest < ResponseError; end
+    class BucketAlreadyExists < ResponseError; end
+    class BucketAlreadyOwnedByYou < ResponseError; end
+    class BucketNotEmpty < ResponseError; end
+    class CredentialsNotSupported < ResponseError; end
+    class CrossLocationLoggingProhibited < ResponseError; end
+    class EntityTooSmall < ResponseError; end
+    class EntityTooLarge < ResponseError; end
+    class ExpiredToken < ResponseError; end
+    class IncompleteBody < ResponseError; end
+    class IncorrectNumberOfFilesInPostRequestPOST < ResponseError; end
+    class InlineDataTooLarge < ResponseError; end
+    class InternalError < ResponseError; end
+    class InvalidAccessKeyId < ResponseError; end
+    class InvalidAddressingHeader < ResponseError; end
+    class InvalidArgument < ResponseError; end
+    class InvalidBucketName < ResponseError; end
+    class InvalidDigest < ResponseError; end
+    class InvalidLocationConstraint < ResponseError; end
+    class InvalidPayer < ResponseError; end
+    class InvalidPolicyDocument < ResponseError; end
+    class InvalidRange < ResponseError; end
+    class InvalidSecurity < ResponseError; end
+    class InvalidSOAPRequest < ResponseError; end
+    class InvalidStorageClass < ResponseError; end
+    class InvalidTargetBucketForLogging < ResponseError; end
+    class InvalidToken < ResponseError; end
+    class InvalidURI < ResponseError; end
+    class KeyTooLong < ResponseError; end
+    class MalformedACLError < ResponseError; end
+    class MalformedACLError < ResponseError; end
+    class MalformedPOSTRequest < ResponseError; end
+    class MalformedXML < ResponseError; end
+    class MaxMessageLengthExceeded < ResponseError; end
+    class MaxPostPreDataLengthExceededErrorYour < ResponseError; end
+    class MetadataTooLarge < ResponseError; end
+    class MethodNotAllowed < ResponseError; end
+    class MissingAttachment < ResponseError; end
+    class MissingContentLength < ResponseError; end
+    class MissingRequestBodyError < ResponseError; end
+    class MissingSecurityElement < ResponseError; end
+    class MissingSecurityHeader < ResponseError; end
+    class NoLoggingStatusForKey < ResponseError; end
+    class NoSuchBucket < ResponseError; end
+    class NoSuchKey < ResponseError; end
+    class NotImplemented < ResponseError; end
+    class NotSignedUp < ResponseError; end
+    class OperationAborted < ResponseError; end
+    class PermanentRedirect < ResponseError; end
+    class PreconditionFailed < ResponseError; end
+    class Redirect < ResponseError; end
+    class RequestIsNotMultiPartContent < ResponseError; end
+    class RequestTimeout < ResponseError; end
+    class RequestTimeTooSkewed < ResponseError; end
+    class RequestTorrentOfBucketError < ResponseError; end
+    class SignatureDoesNotMatch < ResponseError; end
+    class SlowDown < ResponseError; end
+    class TemporaryRedirect < ResponseError; end
+    class TokenRefreshRequired < ResponseError; end
+    class TooManyBuckets < ResponseError; end
+    class UnexpectedContent < ResponseError; end
+    class UnresolvableGrantByEmailAddress < ResponseError; end
+    class UserKeyMustBeSpecified < ResponseError; end
+  end
+end

data/lib/stree/object.rb

@@ -0,0 +1,210 @@
+module Stree
+
+  # Class responsible for handling objects stored in S3 buckets
+  class Object
+    include Parser
+    extend Forwardable
+
+    attr_accessor :content_type, :content_disposition, :content_encoding
+    attr_reader :last_modified, :etag, :size, :bucket, :key, :acl
+    attr_writer :content
+
+    def_instance_delegators :bucket, :name, :service, :bucket_request, :vhost?, :host, :path_prefix
+    def_instance_delegators :service, :protocol, :port
+    private_class_method :new
+
+    # Compares the object with other object. Returns true if the key
+    # of the objects are the same, and both have the same buckets (see
+    # bucket equality)
+    def ==(other)
+      self.key == other.key and self.bucket == other.bucket
+    end
+
+    # Returns full key of the object: e.g. +bucket-name/object/key.ext+
+    def full_key
+      [name, key].join("/")
+    end
+
+    # Assigns a new +key+ to the object, raises ArgumentError if given
+    # key is not valid key name
+    def key=(key)
+      raise ArgumentError.new("Invalid key name: #{key}") unless key_valid?(key)
+      @key ||= key
+    end
+
+    # Assigns a new ACL to the object. Please note that ACL is not
+    # retrieved from the server and set to "public-read" by default.
+    # ==== Example
+    #   object.acl = :public_read
+    def acl=(acl)
+      @acl = acl.to_s.gsub("_", "-") if acl
+    end
+
+    # Retrieves the object from the server. Method is used to download
+    # object information only (content-type, size and so on). It does
+    # NOT download the content of the object (use the content method
+    # to do it).
+    def retrieve
+      get_object(:headers => { :range => 0..0 })
+      self
+    end
+
+    # Retrieves the object from the server, returns true if the
+    # object exists or false otherwise. Uses retrieve method, but
+    # catches NoSuchKey exception and returns false when it happens
+    def exists?
+      retrieve
+      true
+    rescue Error::NoSuchKey
+      false
+    end
+
+    # Download the content of the object, and caches it. Pass true
+    # to clear the cache and download the object again.
+    def content(reload = false)
+      if reload or @content.nil?
+        get_object
+      end
+      @content
+    end
+
+    # Saves the object, returns true if successfull.
+    def save
+      put_object
+      true
+    end
+
+    # Copies the file to another key and/or bucket.
+    # ==== Options:
+    # +key+:: new key to store object in
+    # +bucket+:: new bucket to store object in (instance of Stree::Bucket)
+    # +acl+:: acl of the copied object (default: "public-read")
+    # +content_type+:: content type of the copied object (default: "application/octet-stream")
+    def copy(options = {})
+      copy_object(options)
+    end
+
+    # Destroys the file on the server
+    def destroy
+      delete_object
+      true
+    end
+
+    # Returns Object's URL using protocol specified in Service,
+    # e.g. http://domain.com.s3.amazonaws.com/key/with/path.extension
+    def url
+      URI.escape("#{protocol}#{host}/#{path_prefix}#{key}")
+    end
+
+    # Returns Object's CNAME URL (without s3.amazonaws.com suffix)
+    # using protocol specified in Service,
+    # e.g. http://domain.com/key/with/path.extension. (you have to set
+    # the CNAME in your DNS before you use the CNAME URL schema).
+    def cname_url
+      URI.escape("#{protocol}#{name}/#{key}") if bucket.vhost?
+    end
+
+    def inspect #:nodoc:
+      "#<#{self.class}:/#{name}/#{key}>"
+    end
+
+    private
+
+    attr_writer :last_modified, :etag, :size, :original_key, :bucket
+
+    def copy_object(options = {})
+      key = options[:key] or raise ArgumentError, "No key given"
+      raise ArgumentError.new("Invalid key name: #{key}") unless key_valid?(key)
+      bucket = options[:bucket] || self.bucket
+
+      headers = {}
+
+      headers[:x_amz_acl] = options[:acl] || acl || "public-read"
+      headers[:content_type] = options[:content_type] || content_type || "application/octet-stream"
+      headers[:content_encoding] = options[:content_encoding] if options[:content_encoding]
+      headers[:content_disposition] = options[:content_disposition] if options[:content_disposition]
+      headers[:x_amz_copy_source] = full_key
+      headers[:x_amz_metadata_directive] = "REPLACE"
+      headers[:x_amz_copy_source_if_match] = options[:if_match] if options[:if_match]
+      headers[:x_amz_copy_source_if_none_match] = options[:if_none_match] if options[:if_none_match]
+      headers[:x_amz_copy_source_if_unmodified_since] = options[:if_modified_since] if options[:if_modified_since]
+      headers[:x_amz_copy_source_if_modified_since] = options[:if_unmodified_since] if options[:if_unmodified_since]
+
+      response = bucket.send(:bucket_request, :put, :path => key, :headers => headers)
+      object_attributes = parse_copy_object_result(response.body)
+
+      object = Object.send(:new, bucket, object_attributes.merge(:key => key, :size => size))
+      object.acl = response[:x_amz_acl]
+      object.content_type = response[:content_type]
+      object.content_encoding = response[:content_encoding]
+      object.content_disposition = response[:content_disposition]
+      object
+    end
+
+    def get_object(options = {})
+      response = object_request(:get, options)
+      parse_headers(response)
+    end
+
+    def put_object
+      body = content.is_a?(IO) ? content.read : content
+      response = object_request(:put, :body => body, :headers => dump_headers)
+      parse_headers(response)
+    end
+
+    def delete_object(options = {})
+      object_request(:delete)
+    end
+
+    def initialize(bucket, options = {})
+      self.bucket = bucket
+      self.key = options[:key]
+      self.last_modified = options[:last_modified]
+      self.etag = options[:etag]
+      self.size = options[:size]
+    end
+
+    def object_request(method, options = {})
+      bucket_request(method, options.merge(:path => key))
+    end
+
+    def last_modified=(last_modified)
+      @last_modified = Time.parse(last_modified) if last_modified
+    end
+
+    def etag=(etag)
+      @etag = etag[1..-2] if etag
+    end
+
+    def key_valid?(key)
+      if (key.nil? or key.empty? or key =~ %r#//#)
+        false
+      else
+        true
+      end
+    end
+
+    def dump_headers
+      headers = {}
+      headers[:x_amz_acl] = @acl || "public-read"
+      headers[:content_type] = @content_type || "application/octet-stream"
+      headers[:content_encoding] = @content_encoding if @content_encoding
+      headers[:content_disposition] = @content_disposition if @content_disposition
+      headers
+    end
+
+    def parse_headers(response)
+      self.etag = response["etag"]
+      self.content_type = response["content-type"]
+      self.content_disposition = response["content-disposition"]
+      self.content_encoding = response["content-encoding"]
+      self.last_modified = response["last-modified"]
+      if response["content-range"]
+        self.size = response["content-range"].sub(/[^\/]+\//, "").to_i
+      else
+        self.size = response["content-length"]
+        self.content = response.body
+      end
+    end
+  end
+end

data/lib/stree/parser.rb

@@ -0,0 +1,48 @@
+module Stree
+  module Parser
+    include REXML
+
+    def rexml_document(xml)
+      xml.force_encoding(Encoding::UTF_8) if xml.respond_to? :force_encoding
+      Document.new(xml)
+    end
+
+    def parse_list_all_my_buckets_result(xml)
+      names = []
+      rexml_document(xml).elements.each("ListAllMyBucketsResult/Buckets/Bucket/Name") { |e| names << e.text }
+      names
+    end
+
+    def parse_location_constraint(xml)
+      rexml_document(xml).elements["LocationConstraint"].text
+    end
+
+    def parse_list_bucket_result(xml)
+      objects_attributes = []
+      rexml_document(xml).elements.each("ListBucketResult/Contents") do |e|
+        object_attributes = {}
+        object_attributes[:key] = e.elements["Key"].text
+        object_attributes[:etag] = e.elements["ETag"].text
+        object_attributes[:last_modified] = e.elements["LastModified"].text
+        object_attributes[:size] = e.elements["Size"].text
+        objects_attributes << object_attributes
+      end
+      objects_attributes
+    end
+
+    def parse_copy_object_result(xml)
+      object_attributes = {}
+      document = rexml_document(xml)
+      object_attributes[:etag] = document.elements["CopyObjectResult/ETag"].text
+      object_attributes[:last_modified] = document.elements["CopyObjectResult/LastModified"].text
+      object_attributes
+    end
+
+    def parse_error(xml)
+      document = rexml_document(xml)
+      code = document.elements["Error/Code"].text
+      message = document.elements["Error/Message"].text
+      [code, message]
+    end
+  end
+end

data/lib/stree/roxy/moxie.rb

@@ -0,0 +1,58 @@
+# Copyright (c) 2008 Ryan Daigle
+
+# Permission is hereby granted, free of charge, to any person
+# obtaining a copy of this software and associated documentation files
+# (the "Software"), to deal in the Software without restriction,
+# including without limitation the rights to use, copy, modify, merge,
+# publish, distribute, sublicense, and/or sell copies of the Software,
+# and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+module Stree
+  module Roxy # :nodoc:all
+    module Moxie
+      # Set up this class to proxy on the given name
+      def proxy(name, options = {}, &block)
+
+        # Make sure args are OK
+        original_method = method_defined?(name) ? instance_method(name) : nil
+        raise "Cannot proxy an existing method, \"#{name}\", and also have a :to option.  Please use one or the other." if
+          original_method and options[:to]
+
+        # If we're proxying an existing method, we need to store
+        # the original method and move it out of the way so
+        # we can take over
+        if original_method
+          new_method = "proxied_#{name}"
+          alias_method new_method, "#{name}"
+          options[:to] = original_method
+        end
+
+        # Thanks to Jerry for this simplification of my original class_eval approach
+        # http://ryandaigle.com/articles/2008/11/10/implement-ruby-proxy-objects-with-roxy/comments/8059#comment-8059
+        if !original_method or original_method.arity == 0
+          define_method name do
+            @proxy_for ||= {}
+            @proxy_for[name] ||= Proxy.new(self, options, nil, &block)
+          end
+        else
+          define_method name do |*args|
+            Proxy.new(self, options, args, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stree/roxy/proxy.rb

@@ -0,0 +1,72 @@
+# Copyright (c) 2008 Ryan Daigle
+
+# Permission is hereby granted, free of charge, to any person
+# obtaining a copy of this software and associated documentation files
+# (the "Software"), to deal in the Software without restriction,
+# including without limitation the rights to use, copy, modify, merge,
+# publish, distribute, sublicense, and/or sell copies of the Software,
+# and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+module Stree
+  module Roxy # :nodoc:all
+    # The very simple proxy class that provides a basic pass-through
+    # mechanism between the proxy owner and the proxy target.
+    class Proxy
+
+      alias :proxy_instance_eval :instance_eval
+      alias :proxy_extend :extend
+
+      # Make sure the proxy is as dumb as it can be.
+      # Blatanly taken from Jim Wierich's BlankSlate post:
+      # http://onestepback.org/index.cgi/Tech/Ruby/BlankSlate.rdoc
+      instance_methods.each { |m| undef_method m unless m =~ /(^__|^proxy_|^object_id)/ }
+
+      def initialize(owner, options, args, &block)
+        @owner = owner
+        @target = options[:to]
+        @args = args
+
+        # Adorn with user-provided proxy methods
+        [options[:extend]].flatten.each { |ext| proxy_extend(ext) } if options[:extend]
+        proxy_instance_eval &block if block_given?
+      end
+
+      def proxy_owner
+        @owner
+      end
+
+      def proxy_target
+        if @target.is_a?(Proc)
+          @target.call(@owner)
+        elsif @target.is_a?(UnboundMethod)
+          bound_method = @target.bind(proxy_owner)
+          bound_method.arity == 0 ? bound_method.call : bound_method.call(*@args)
+        else
+          @target
+        end
+      end
+
+      # def inspect
+      #   "#<S3::Roxy::Proxy:0x#{object_id.to_s(16)}>"
+      # end
+
+      # Delegate all method calls we don't know about to target object
+      def method_missing(sym, *args, &block)
+        proxy_target.__send__(sym, *args, &block)
+      end
+    end
+  end
+end