s3restful 0.2.7

data/CHANGELOG.md

@@ -0,0 +1,24 @@
+Changelog
+=============
+
+- re-license under Apache 2.0
+
+0.2.5
+
+- fix building
+
+0.2.3
+
+- yank older version
+
+0.2.2
+
+- Refactor version and build code
+
+0.2.1
+
+- Return the response object on get so that the data can be streamed [carlism]
+
+0.2.0
+
+- Initial release

data/Gemfile

@@ -0,0 +1,10 @@
+source "http://rubygems.org"
+
+gem "em-http-request"
+
+group :development do
+  gem "shoulda", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.4"
+  gem "mocha"
+end

data/LICENSE.txt

@@ -0,0 +1,13 @@
+Copyright 2010-2011 Peritor GmbH
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,230 @@
+important Note
+==============
+s3restful is a modified version of the Happening gem written by Jonathan Weiss (https://github.com/peritor/happening) under the Apache 2.0 license.
+S3-restufl introduces compatibility patches to enable the original Happening gem to communicate with other S3 API based storage system like Cumulus and Walrus.
+It has also been improved to implement streaming uploads (credits go to Viktors Buls Happening fork at https://github.com/krukid/happening).
+
+This README has been adapted from the original Happening gem. Lincense was mantained with its original authors.
+
+--------------
+
+Amazon S3 Ruby library that leverages [EventMachine](http://rubyeventmachine.com/) and [em-http-request](http://github.com/igrigorik/em-http-request).
+
+By using EventMachine s3restful does not block on S3 downloads/uploads thus allowing for a higher concurrency.
+
+s3restful was developed by [Peritor](http://www.peritor.com) for usage inside Nanite/EventMachine. 
+Alternatives like RightAws block during the HTTP calls thus blocking the Nanite-Agent.
+
+For now it only supports GET, PUT and DELETE operations on S3 items. The PUT operations support S3 ACLs/permissions.
+s3restful will handle redirects and retries on errors by default.
+
+s3restful also supports other S3 compatible APIs, like Eucalyptus Walrus and Nimbus Cumulus. See instructions below
+for more details.
+
+Installation
+============
+
+    gem install s3restful
+
+Usage
+=============
+
+    require 's3restful'
+    
+    EM.run do
+      item = S3restful::S3::Item.new('bucket', 'item_id')
+      item.get # non-authenticated download, works only for public-read content
+    
+      item = S3restful::S3::Item.new('bucket', 'item_id', :aws_access_key_id => 'Your-ID', :aws_secret_access_key => 'secret')
+      item.get # authenticated download
+      
+      item.put("The new content")
+      
+      item.delete
+    end
+    
+The above examples are a bit useless, as you never get any content back. 
+You need to specify a callback that interacts with the http response:
+
+    EM.run do
+      item = S3restful::S3::Item.new('bucket', 'item_id', :aws_access_key_id => 'Your-ID', :aws_secret_access_key => 'secret')
+      item.get do |response|
+        puts "the response content is: #{response.response}"
+        EM.stop
+      end
+    end
+    
+This will enqueue your download and run it in the EventMachine event loop.
+
+You can also react to errors:
+
+    EM.run do
+      on_error = Proc.new {|response| puts "An error occured: #{response.response_header.status}"; EM.stop }
+      item = S3restful::S3::Item.new('bucket', 'item_id', :aws_access_key_id => 'Your-ID', :aws_secret_access_key => 'secret')
+      item.get(:on_error => on_error) do |response|
+        puts "the response content is: #{response.response}" 
+        EM.stop
+      end
+    end
+
+If you don't supply an error handler yourself, s3restful will be default raise an Exception.
+
+Downloading many files could look like this:
+
+    EM.run do
+      count = 100
+      on_error = Proc.new {|http| puts "An error occured: #{http.response_header.status}"; EM.stop if count <= 0}
+      on_success = Proc.new {|http| puts "the response is: #{http.response}"; EM.stop if count <= 0}
+      
+      count.times do |i|
+        item = S3restful::S3::Item.new('bucket', "item_#{i}", :aws_access_key_id => 'Your-ID', :aws_secret_access_key => 'secret')
+        item.get(:on_success => on_success, :on_error => on_error)
+      end
+    end
+    
+Upload
+=============
+
+s3restful supports the simple S3 PUT upload:
+  
+    EM.run do
+      on_error = Proc.new {|http| puts "An error occured: #{http.response_header.status}"; EM.stop }
+      item = S3restful::S3::Item.new('bucket', 'item_id', :aws_access_key_id => 'Your-ID', :aws_secret_access_key => 'secret', :on_success => on_success, :on_error => on_error)
+      item.put( File.read('/etc/passwd'), :on_error => on_error ) do |response|
+        puts "Upload finished!"; EM.stop 
+      end
+    end
+    
+Setting permissions looks like this:
+
+    EM.run do
+      on_error = Proc.new {|http| puts "An error occured: #{http.response_header.status}"; EM.stop }
+      on_success = Proc.new {|http| puts "the response is: #{http.response}"; EM.stop }
+      item = S3restful::S3::Item.new('bucket', 'item_id', :aws_access_key_id => 'Your-ID', :aws_secret_access_key => 'secret', :permissions => 'public-write')
+      item.get(:on_success => on_success, :on_error => on_error)
+    end
+    
+Custom headers:
+
+    EM.run do
+      on_error = Proc.new {|http| puts "An error occured: #{http.response_header.status}"; EM.stop }
+      on_success = Proc.new {|http| puts "the response is: #{http.response}"; EM.stop }
+      item = S3restful::S3::Item.new('bucket', 'item_id', :aws_access_key_id => 'Your-ID', :aws_secret_access_key => 'secret', :permissions => 'public-write')
+      item.put(:on_success => on_success, 
+               :on_error => on_error, 
+               :headers => {
+                 'Cache-Control' => "max-age=252460800", 
+                 'Content-Type' => 'text/html', 
+                 'Expires' => 'Fri, 16 Nov 2018 22:09:29 GMT', 
+                 'x-amz-meta-abc' => 'ABC'
+                })
+    end
+
+
+Deleting
+=============
+
+s3restful support the simple S3 PUT upload:
+  
+    EM.run do
+      on_error = Proc.new {|response| puts "An error occured: #{response.response_header.status}"; EM.stop }
+      item = S3restful::S3::Item.new('bucket', 'item_id', :aws_access_key_id => 'Your-ID', :aws_secret_access_key => 'secret')
+      item.delete(:on_error => on_error) do |response|
+        puts "Deleted!"
+        EM.stop
+      end
+    end
+
+Amazon returns no content on delete, so having a success handler is usually not needed for delete operations.
+
+Head
+=============
+
+You can also just load the headers of an S3 item:
+  
+    EM.run do
+      on_error = Proc.new {|response| puts "An error occured: #{response.response_header.status}"; EM.stop }
+      item = S3restful::S3::Item.new('bucket', 'item_id', :aws_access_key_id => 'Your-ID', :aws_secret_access_key => 'secret')
+      item.head(:on_error => on_error) do |response|
+        puts "Headers: #{response.inspect}"
+        EM.stop
+      end
+    end
+
+
+    
+Streaming
+=============
+
+The response data can also be streamed:    
+  
+    EM.run do
+      item = S3restful::S3::Item.new( bucket...
+	  item.get(:on_error => on_error, :on_success => on_success ).stream do |chunk|
+	    # .. handle the individual chunk          
+	  end
+    end
+    
+
+SSL Support
+=============
+
+s3restful will use SSL/HTTPS by default. What it cannot do by default is verify the SSL certificate. This means
+that traffic is encrypted but nobody can say if the SSL-endpoint is the one you except. In order to verify the 
+SSL certificate you need to provide s3restful with the path to a certificate CA collection in PEM format:
+
+    S3restful::S3.ssl_options[:cert_chain_file] = '/etc/ca-bundle.crt'
+    
+You can also set this option on each item:
+
+    S3restful::S3::Item.new('bucket', 'item_id', 
+      :aws_access_key_id => 'A', 
+      :aws_secret_access_key => 'B',
+      :ssl => {
+        :cert_chain_file => '/etc/ca-bundle.crt'
+      }
+      
+Or even on the request:
+
+    item.get(:ssl => {:cert_chain_file => '/etc/ca-bundle.crt'})
+    
+The SSL options are directly passed to EventMachine, see the [EventMachine documentation](http://eventmachine.rubyforge.org/EventMachine/Connection.html#M000296) for more information on the SSL support.
+
+
+Walrus
+=============
+
+s3restful also supports interacting with Walrus storage from the Eucalyptus cloud. The only difference is in the Item
+initialization. Here you should prepend the bucket name with the 'services/Walrus/' string, as this is the base path
+used by the Walrus API and should be signed allong with the bucket name. You should specify the host address and port
+where Walrus listens for incoming requests too.
+
+     S3restful::S3::Item.new('services/Walrus/bucket', 'item_id', :server => 'Walrus address', :port => 8773, :protocol => 'http',
+        :aws_access_key_id => 'Walrus ID', :aws_secret_access_key => 'Walrus secret')
+
+
+Cumulus
+=============
+
+s3restful also supports interacting with Cumulus storage from the Nimbus cloud. The only difference is in the Item
+initialization, where you should specify the host address and port where Cumulus listens for incoming requests.
+
+     S3restful::S3::Item.new('bucket', 'item_id', :server => 'cumulus address', :port => 8888, :protocol => 'http',
+        :aws_access_key_id => 'cumulus ID', :aws_secret_access_key => 'cumulus secret')
+
+
+Credits
+=============
+
+The AWS signing and canonical request description is based on [RightAws](http://github.com/rightscale/right_aws).
+    
+    
+License
+=============
+
+Happening is licensed under the Apache 2.0 license. See LICENSE.txt
+
+About
+=============
+
+Happening was written by [Jonathan Weiss](http://twitter.com/jweiss) for [Peritor](http://www.peritor.com).

data/Rakefile

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+require File.expand_path("./lib/s3restful")
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "s3restful"
+  gem.homepage = "http://github.com/peritor/s3restful"
+  gem.license = "BSD"
+  gem.summary = %Q{An EventMachine based S3 client }
+  gem.description = %Q{An EventMachine based S3 client }
+  gem.email = "jw@innerewut.de"
+  gem.authors = ["Jonathan Weiss"]
+  gem.version = S3restful::VERSION
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = "test/**/*_test.rb"
+  t.verbose = true
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "hello-gem #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.2.7

data/benchmark/right_aws.rb

@@ -0,0 +1,106 @@
+require File.dirname(__FILE__) + '/../s3restful'
+
+require 'benchmark'
+require 'right_aws'
+
+AWS_ACCESS_KEY_ID = ENV['AWS_ACCESS_KEY_ID'] or raise "please set AWS_ACCESS_KEY_ID='your-key'"
+AWS_SECRET_ACCESS_KEY = ENV['AWS_SECRET_ACCESS_KEY'] or raise "please set AWS_SECRET_ACCESS_KEY='your-scret'"
+
+BUCKET = 's3restful-benchmark'
+FILE   = 'the_file_name'
+PROTOCOL = 'https'
+
+COUNT = 100
+CONTENT = File.read('/tmp/VzLinuxUG.pdf')
+
+command = ARGV.first || 'get'
+
+puts "running command: #{command}"
+
+if command == 'get'
+  Benchmark.bm(7) do |x|
+    x.report("RightAWS - Get an item") do
+      count = COUNT
+      s3 = RightAws::S3Interface.new(AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, :protocol => PROTOCOL)
+      count.times do |i|
+        s3.get_object(BUCKET, FILE)
+        print '.'; $stdout.flush
+      end
+    end
+  
+    puts ""
+    x.report("S3restful - Get an item") do 
+      puts ""
+      count = COUNT
+      on_success = Proc.new do |http|
+        print '.'; $stdout.flush
+        count = count - 1
+        EM.stop if count <= 0
+      end
+
+      on_error = Proc.new do |http|
+        puts "Status: #{http.response_header.status}"
+        puts "Header: #{http.response_header.inspect}"
+        puts "Content:"
+        puts http.response.inspect + "\n"
+        count = count - 1
+        EM.stop if count <= 0
+      end
+    
+      EM.run do
+        count.times do |i|
+          item = S3restful::S3::Item.new(BUCKET, FILE, :protocol => PROTOCOL, :on_success => on_success, :on_error => on_error)
+          item.get
+        end
+      end
+    end  
+  end
+
+elsif command == 'put'
+  Benchmark.bm(7) do |x|
+    x.report("RightAWS - Put an item") do
+      count = COUNT
+      s3 = RightAws::S3Interface.new(AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, :protocol => PROTOCOL)
+      count.times do |i|
+        s3.put(BUCKET, "upload_test_right_aws_#{i}", CONTENT)
+        print '.'; $stdout.flush
+      end
+    end
+  
+    puts ""
+    x.report("S3restful - Put an item") do 
+      puts ""
+      count = COUNT
+      on_success = Proc.new do |http|
+        #puts "Success"
+        puts "Status: #{http.response_header.status}" unless http.response_header.status == 200
+        #puts "Header: #{http.response_header.inspect}"
+        #puts "Content:"
+        #puts http.response.inspect + "\n"
+        print '.'; $stdout.flush
+        count = count - 1
+        EM.stop if count <= 0
+      end
+
+      on_error = Proc.new do |http|
+        puts "Error"
+        puts "Status: #{http.response_header.status}"
+        puts "Header: #{http.response_header.inspect}"
+        puts "Content:"
+        puts http.response.inspect + "\n"
+        count = count - 1
+        EM.stop if count <= 0
+      end
+    
+      EM.run do        
+        count.times do |i|
+          item = S3restful::S3::Item.new(BUCKET, "upload_test_s3restful_#{i}", :protocol => PROTOCOL, :on_success => on_success, :on_error => on_error, :aws_access_key_id => AWS_ACCESS_KEY_ID, :aws_secret_access_key => AWS_SECRET_ACCESS_KEY)
+          item.put(CONTENT)
+        end
+      end
+    end  
+  end
+
+else
+  puts "unknown command: #{command}"  
+end

data/lib/s3restful/aws.rb

@@ -0,0 +1,65 @@
+require 'time'
+module S3restful
+  class AWS
+    include Utils
+    
+    AMAZON_HEADER_PREFIX   = 'x-amz-'
+    AMAZON_METADATA_PREFIX = 'x-amz-meta-'
+    DIGEST = OpenSSL::Digest.new('sha1')
+    
+    attr_accessor :aws_access_key_id, :aws_secret_access_key
+    
+    def initialize(aws_access_key_id, aws_secret_access_key)
+      @aws_access_key_id = aws_access_key_id
+      @aws_secret_access_key = aws_secret_access_key
+      raise ArgumentError, "need AWS Access Key Id and AWS Secret Key" if blank?(aws_access_key_id) || blank?(aws_secret_access_key)
+    end
+    
+    def sign(method, path, headers={})
+      headers = {
+        'date' => utc_httpdate
+      }.update(headers)
+      
+      request_description = canonical_request_description(method, path, headers)
+      headers.update("Authorization" => "AWS #{aws_access_key_id}:#{generate_signature(request_description)}")
+    end
+    
+  protected
+        
+    def utc_httpdate
+      Time.now.utc.httpdate
+    end
+
+    def generate_signature(request_description)
+      Base64.encode64(OpenSSL::HMAC.digest(DIGEST, aws_secret_access_key, request_description)).strip
+    end
+    
+    def canonical_request_description(method, path, headers = {}, expires = nil)
+      s3_attributes = {}
+      headers.each do |key, value|
+        key = key.downcase
+        s3_attributes[key] = value.to_s.strip if key.match(/^#{AMAZON_HEADER_PREFIX}|^content-md5$|^content-type$|^date$/o)
+      end
+      s3_attributes['content-type'] ||= ''
+      s3_attributes['content-md5']  ||= ''
+      s3_attributes['date'] = '' if s3_attributes.has_key?('x-amz-date')
+      s3_attributes['date'] = expires if expires
+
+      description = "#{method}\n"
+      s3_attributes.sort { |a, b| a[0] <=> b[0] }.each do |key, value|
+        description << (key.match(/^#{AMAZON_HEADER_PREFIX}/o) ? "#{key}:#{value}\n" : "#{value}\n")
+      end
+      
+      # ignore all parameters by default
+      description << path.gsub(/\?.*$/, '')
+      
+      # handle amazon parameters
+      description << '?acl'      if path[/[&?]acl($|&|=)/]
+      description << '?torrent'  if path[/[&?]torrent($|&|=)/]
+      description << '?location' if path[/[&?]location($|&|=)/]
+      description << '?logging'  if path[/[&?]logging($|&|=)/]
+      description
+    end
+    
+  end
+end

data/lib/s3restful/log.rb

@@ -0,0 +1,40 @@
+module S3restful
+  class Log
+    
+    @@logger = Logger.new(STDOUT)
+    @@logger.level = Logger::ERROR
+    
+    def self.logger=(log)
+      @@logger = log
+    end
+    
+    def self.logger
+      @@logger
+    end
+    
+    def self.level=(lev)
+      logger.level = lev
+    end
+    
+    def self.level
+      logger.level
+    end
+    
+    def self.debug(msg)
+      logger.debug("S3restful: #{msg}")
+    end
+    
+    def self.info(msg)
+      logger.debug("S3restful: #{msg}")
+    end
+    
+    def self.warn(msg)
+      logger.debug("S3restful: #{msg}")
+    end
+    
+    def self.error(msg)
+      logger.debug("S3restful: #{msg}")
+    end
+    
+  end
+end

data/lib/s3restful/s3/item.rb

@@ -0,0 +1,136 @@
+require 'uri'
+require 'cgi'
+
+module S3restful
+  module S3
+    class Item
+      include Utils
+
+      REQUIRED_FIELDS = [:server]
+      VALID_HEADERS = ['Cache-Control', 'Content-Disposition', 'Content-Encoding', 'Content-Length', 'Content-MD5', 'Content-Type', 'Expect', 'Expires']
+
+      attr_accessor :bucket, :aws_id, :options
+
+      def initialize(bucket, aws_id, options = {})
+        @options = {
+          :timeout => 10,
+          :server => 's3.amazonaws.com',
+          :protocol => 'https',
+          :aws_access_key_id => nil,
+          :aws_secret_access_key => nil,
+          :retry_count => 4,
+          :permissions => 'private',
+          :ssl => S3restful::S3.ssl_options
+        }.update(symbolize_keys(options))
+        assert_valid_keys(options, :timeout, :server, :port, :protocol, :aws_access_key_id, :aws_secret_access_key, :retry_count, :permissions, :ssl)
+        @aws_id = aws_id.to_s
+        @bucket = bucket.to_s
+
+        validate
+      end
+
+      def head(request_options = {}, &blk)
+        headers = needs_to_sign? ? aws.sign("HEAD", path) : {}
+        request_options[:on_success] = blk if blk
+        request_options.update(:headers => headers)
+        S3restful::S3::Request.new(:head, url, {:ssl => options[:ssl]}.update(request_options)).execute
+      end
+
+      def get(request_options = {}, &blk)
+        headers = needs_to_sign? ? aws.sign("GET", path) : {}
+        request_options[:on_success] = blk if blk
+        request_options.update(:headers => headers)
+        S3restful::S3::Request.new(:get, url, {:ssl => options[:ssl]}.update(request_options)).execute
+      end
+
+      def aget(request_options = {}, &blk)
+        headers = needs_to_sign? ? aws.sign("GET", path) : {}
+        request_options[:on_success] = blk if blk
+        request_options.update(:headers => headers)
+        S3restful::S3::Request.new(:aget, url, {:ssl => options[:ssl]}.update(request_options)).execute
+      end
+
+      def put(data, request_options = {}, &blk)
+        headers = construct_aws_headers('PUT', request_options.delete(:headers) || {})
+        request_options[:on_success] = blk if blk
+        request_options.update(:headers => headers, :data => data)
+        S3restful::S3::Request.new(:put, url, {:ssl => options[:ssl]}.update(request_options)).execute
+      end
+
+      def store(file_path, request_options = {}, &blk)
+        headers = construct_aws_headers('PUT', request_options.delete(:headers) || {})
+        request_options[:on_success] = blk if blk
+        request_options.update(:headers => headers, :file => file_path)
+        S3restful::S3::Request.new(:put, url, {:ssl => options[:ssl]}.update(request_options)).execute
+      end
+
+      def delete(request_options = {}, &blk)
+        headers = needs_to_sign? ? aws.sign("DELETE", path, {'url' => path}) : {}
+        request_options[:on_success] = blk if blk
+        request_options.update(:headers => headers)
+        S3restful::S3::Request.new(:delete, url, {:ssl => options[:ssl]}.update(request_options)).execute
+      end
+
+      def url
+        uri = options[:port] ? path : path(!dns_bucket?)
+        URI::Generic.new(options[:protocol], nil, server, port, nil, uri, nil, nil, nil).to_s
+      end
+
+      def server
+        return options[:server] if options[:port]
+        dns_bucket? ? "#{bucket}.#{options[:server]}" : options[:server]
+      end
+
+      def path(with_bucket=true)
+        with_bucket ? "/#{bucket}/#{CGI::escape(aws_id)}" : "/#{CGI::escape(aws_id)}"
+      end
+
+    protected
+
+      def needs_to_sign?
+        present?(options[:aws_access_key_id])
+      end
+
+      def dns_bucket?
+        # http://docs.amazonwebservices.com/AmazonS3/2006-03-01/index.html?BucketRestrictions.html
+        return false unless (3..63) === bucket.size
+        bucket.split('.').each do |component|
+          return false unless component[/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/]
+        end
+        true
+      end
+
+      def port
+        options[:port] || (options[:protocol].to_s == 'https' ? 443 : 80)
+      end
+
+      def validate
+        raise ArgumentError, "need a bucket name" unless present?(bucket)
+        raise ArgumentError, "need a AWS Key" unless present?(aws_id)
+
+        REQUIRED_FIELDS.each do |field|
+          raise ArgumentError, "need field #{field}" unless present?(options[field])
+        end
+
+        raise ArgumentError, "unknown protocoll #{options[:protocol]}" unless ['http', 'https'].include?(options[:protocol])
+      end
+
+      def aws
+        @aws ||= S3restful::AWS.new(options[:aws_access_key_id], options[:aws_secret_access_key])
+      end
+
+      def construct_aws_headers(http_method, headers = {})
+        unless headers.keys.all?{|header| VALID_HEADERS.include?(header) || header.to_s.match(/\Ax-amz-/) }
+          raise ArgumentError, "invalid headers. All headers must either one of #{VALID_HEADERS} or start with 'x-amz-'"
+        end
+
+        permissions = options[:permissions] != 'private' ? {'x-amz-acl' => options[:permissions] } : {}
+        headers.update(permissions)
+        headers.update({'url' => path})
+
+        headers = needs_to_sign? ? aws.sign(http_method, path, headers) : headers
+      end
+
+    end
+  end
+end