configure-s3-website-ng 3.0.0

data/lib/configure-s3-website/cloudfront_client.rb

@@ -0,0 +1,172 @@
+require "aws-sdk"
+require 'deep_merge'
+
+module ConfigureS3Website
+  class CloudFrontClient
+    def self.apply_distribution_config(options)
+      config_source = options[:config_source]
+      puts "Detected an existing CloudFront distribution (id #{config_source.cloudfront_distribution_id}) ..."
+
+      live_config = cloudfront(config_source).get_distribution({
+        id: options[:config_source].cloudfront_distribution_id
+      })
+
+      custom_distribution_config = config_source.cloudfront_distribution_config || {}
+      if custom_distribution_config.empty?
+        return
+      end
+      live_distribution_config = live_config.distribution.distribution_config.to_hash
+      custom_distribution_config_with_caller_ref = live_distribution_config.deep_merge!(
+        deep_symbolize(custom_distribution_config.merge({
+          caller_reference: live_config.distribution.distribution_config.caller_reference,
+          comment: 'Updated by the configure-s3-website gem'
+        })),
+        ConfigureS3Website::deep_merge_options
+      )
+      cloudfront(config_source).update_distribution({
+        distribution_config: custom_distribution_config_with_caller_ref,
+        id: options[:config_source].cloudfront_distribution_id,
+        if_match: live_config.etag
+      })
+
+      print_report_on_custom_distribution_config custom_distribution_config_with_caller_ref
+    end
+
+    def self.create_distribution_if_user_agrees(options, standard_input)
+      if options['autocreate-cloudfront-dist'] and options[:headless]
+        puts 'Creating a CloudFront distribution for your S3 website ...'
+        create_distribution options
+      elsif options[:headless]
+        # Do nothing
+      else
+        puts 'Do you want to deliver your website via CloudFront, Amazon’s CDN service? [y/N]'
+        case standard_input.gets.chomp
+        when /(y|Y)/ then create_distribution options
+        end
+      end
+    end
+
+    private
+
+    def self.cloudfront(config_source)
+      Aws::CloudFront::Client.new(
+        region: 'us-east-1',
+        access_key_id: config_source.s3_access_key_id,
+        secret_access_key: config_source.s3_secret_access_key
+      )
+    end
+
+    def self.create_distribution(options)
+      config_source = options[:config_source]
+      custom_distribution_config = config_source.cloudfront_distribution_config || {}
+      distribution = cloudfront(config_source).create_distribution(
+        deep_symbolize new_distribution_config(config_source, custom_distribution_config)
+      ).distribution
+      dist_id = distribution.id
+      print_report_on_new_dist distribution, dist_id, options, config_source
+      config_source.cloudfront_distribution_id = dist_id.to_s
+      puts "  Added setting 'cloudfront_distribution_id: #{dist_id}' into #{config_source.description}"
+      unless custom_distribution_config.empty?
+        print_report_on_custom_distribution_config custom_distribution_config
+      end
+    end
+
+    def self.print_report_on_custom_distribution_config(custom_distribution_config, left_padding = 4)
+      puts '  Applied custom distribution settings:'
+      puts custom_distribution_config.
+        to_yaml.
+        to_s.
+        gsub("---\n", '').
+        gsub(/^/, padding(left_padding))
+    end
+
+    def self.print_report_on_new_dist(distribution, dist_id, options, config_source)
+      config_source = options[:config_source]
+      puts "  The distribution #{dist_id} at #{distribution.domain_name} now delivers the origin #{distribution.distribution_config.origins.items[0].domain_name}"
+      puts '    Please allow up to 15 minutes for the distribution to initialise'
+      puts '    For more information on the distribution, see https://console.aws.amazon.com/cloudfront'
+      if options[:verbose]
+        puts '  Below is the response from the CloudFront API:'
+        puts distribution
+      end
+    end
+
+    def self.new_distribution_config(config_source, custom_cf_settings)
+      {
+        'distribution_config' => {
+          'caller_reference' => 'configure-s3-website gem ' + Time.now.to_s,
+          'default_root_object' => 'index.html',
+          'origins' => {
+            'quantity' => 1,
+            'items' => [
+              {
+                'id' => (origin_id config_source),
+                'domain_name' => "#{config_source.s3_bucket_name}.#{EndpointHelper.s3_website_hostname(config_source.s3_endpoint)}",
+                'custom_origin_config' => {
+                  'http_port' => 80,
+                  'https_port' => 443,
+                  'origin_protocol_policy' => 'http-only'
+                }
+              }
+            ]
+          },
+          'logging' => {
+            'enabled' => 'false',
+            'include_cookies' => 'false',
+            'bucket' => '',
+            'prefix' => ''
+          },
+          'enabled' => 'true',
+          'comment' => 'Created by the configure-s3-website gem',
+          'aliases' => {
+            'quantity' => '0'
+          },
+          'default_cache_behavior' => {
+            'target_origin_id' => (origin_id config_source),
+            'trusted_signers' => {
+              'enabled' => 'false',
+              'quantity' => '0'
+            },
+            'forwarded_values' => {
+              'query_string' => 'true',
+              'cookies' => {
+                'forward' => 'all'
+              }
+            },
+            'viewer_protocol_policy' => 'allow-all',
+            'min_ttl' => '86400'
+          },
+          'cache_behaviors' => {
+            'quantity' => '0'
+          },
+          'price_class' => 'PriceClass_All'
+        }.deep_merge!(custom_cf_settings, ConfigureS3Website::deep_merge_options)
+      }
+    end
+
+    def self.origin_id(config_source)
+      "#{config_source.s3_bucket_name}-S3-origin"
+    end
+
+    def self.padding(amount)
+      padding = ''
+      amount.times { padding << " " }
+      padding
+    end
+
+    def self.deep_symbolize(value)
+      if value.is_a? Hash
+        Hash[value.map { |k,v| [k.to_sym, deep_symbolize(v)] }]
+      elsif value.is_a? Array
+        value.map { |v| deep_symbolize(v) }
+      else
+        value
+      end
+    end
+  end
+  def self.deep_merge_options
+    {
+      :merge_hash_arrays => true
+    }
+  end
+end

data/lib/configure-s3-website/config_source/config_source.rb

@@ -0,0 +1,30 @@
+module ConfigureS3Website
+  class ConfigSource
+    def description
+    end
+
+    def s3_access_key_id
+    end
+
+    def s3_secret_access_key
+    end
+
+    def s3_bucket_name
+    end
+
+    def s3_endpoint
+    end
+
+    def routing_rules
+    end
+
+    def cloudfront_distribution_config
+    end
+
+    def cloudfront_distribution_id
+    end
+
+    def cloudfront_distribution_id=(dist_id)
+    end
+  end
+end

data/lib/configure-s3-website/config_source/file_config_source.rb

@@ -0,0 +1,87 @@
+require 'yaml'
+require 'erb'
+
+module ConfigureS3Website
+  class FileConfigSource < ConfigSource
+    def initialize(yaml_file_path)
+      @yaml_file_path = yaml_file_path
+      @config = FileConfigSource.parse_config yaml_file_path
+    end
+
+    def description
+      @yaml_file_path
+    end
+
+    def s3_access_key_id
+      @config['s3_id']
+    end
+
+    def s3_secret_access_key
+      @config['s3_secret']
+    end
+
+    def profile
+      @config['profile']
+    end
+
+    def s3_bucket_name
+      @config['s3_bucket']
+    end
+
+    def s3_endpoint
+      endpoint = @config['s3_endpoint'] || 'us-east-1'
+      if endpoint == 'EU'
+        'eu-west-1'
+      else
+        endpoint
+      end
+    end
+
+    def routing_rules
+      @config['routing_rules']
+    end
+
+    def index_document
+      @config['index_document']
+    end
+
+    def error_document
+      @config['error_document']
+    end
+
+    def cloudfront_distribution_config
+      @config['cloudfront_distribution_config']
+    end
+
+    def cloudfront_distribution_id
+      @config['cloudfront_distribution_id']
+    end
+
+    def cloudfront_distribution_id=(dist_id)
+      @config['cloudfront_distribution_id'] = dist_id
+      file_contents = File.open(@yaml_file_path).read
+      File.open(@yaml_file_path, 'w') do |file|
+        result = file_contents.gsub(
+          /(s3_bucket:.*$)/,
+          "\\1\ncloudfront_distribution_id: #{dist_id}"
+        )
+        file.write result
+      end
+    end
+
+    private
+
+    def self.parse_config(yaml_file_path)
+      config = YAML.load(ERB.new(File.read(yaml_file_path)).result)
+      validate_config(config, yaml_file_path)
+      config
+    end
+
+    def self.validate_config(config, yaml_file_path)
+      # make sure the bucket name is configured at a minimum
+      if not config.keys.include?'s3_bucket'
+        raise "File #{yaml_file_path} does not contain the required key 's3_bucket'"
+      end
+    end
+  end
+end

data/lib/configure-s3-website/endpoint_helper.rb

@@ -0,0 +1,26 @@
+module ConfigureS3Website
+  class EndpointHelper
+    def self.s3_website_hostname(region)
+      if old_regions.include?(region)
+        "s3-website-#{region}.amazonaws.com"
+      else
+        "s3-website.#{region}.amazonaws.com"
+      end
+    end
+
+    private
+
+    def self.old_regions
+      [
+        'us-east-1',
+        'us-west-1',
+        'us-west-2',
+        'ap-southeast-1',
+        'ap-southeast-2',
+        'ap-northeast-1',
+        'eu-west-1',
+        'sa-east-1'
+      ]
+    end
+  end
+end

data/lib/configure-s3-website/http_helper.rb

@@ -0,0 +1,74 @@
+module ConfigureS3Website
+  class HttpHelper
+    def self.call_cloudfront_api(path, method, body, config_source, headers = {})
+      date = Time.now.utc.strftime("%a, %d %b %Y %H:%M:%S %Z")
+      digest = create_cloudfront_digest(config_source, date)
+      self.call_api(
+        path,
+        method,
+        body,
+        config_source,
+        'cloudfront.amazonaws.com',
+        digest,
+        date,
+        headers
+      )
+    end
+
+    private
+
+    def self.call_api(path, method, body, config_source, hostname, digest, date, additional_headers = {})
+      url = "https://#{hostname}#{path}"
+      uri = URI.parse(url)
+      req = method.new(uri.to_s)
+      req.initialize_http_header({
+        'Date' => date,
+        'Content-Type' => '',
+        'Content-Length' => body.length.to_s,
+        'Authorization' => "AWS %s:%s" % [config_source.s3_access_key_id, digest]
+      }.merge(additional_headers))
+      req.body = body
+      http = Net::HTTP.new(uri.host, uri.port)
+      # http.set_debug_output $stderr
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      res = http.request(req)
+      if res.code.to_i.between? 200, 299
+        res
+      else
+        raise ConfigureS3Website::ErrorParser.create_error res.body
+      end
+    end
+
+    def self.create_cloudfront_digest(config_source, date)
+      digest = Base64.encode64(
+        OpenSSL::HMAC.digest(
+          OpenSSL::Digest.new('sha1'),
+          config_source.s3_secret_access_key,
+          date
+        )
+      ).strip
+    end
+  end
+end
+
+private
+
+module ConfigureS3Website
+  class ErrorParser
+    def self.create_error(amazon_error_xml)
+      error_code = amazon_error_xml.delete('\n').match(/<Code>(.*?)<\/Code>/)[1]
+      begin
+        Object.const_get("#{error_code}Error").new
+      rescue NameError
+        GenericError.new(amazon_error_xml)
+      end
+    end
+  end
+end
+
+class GenericError < StandardError
+  def initialize(error_message)
+    super("AWS API call failed:\n#{error_message}")
+  end
+end

data/lib/configure-s3-website/runner.rb

@@ -0,0 +1,31 @@
+module ConfigureS3Website
+  class Runner
+    def self.run(options, standard_input = STDIN)
+      S3Client.configure_website options
+      maybe_create_or_update_cloudfront options, standard_input
+    end
+
+    private
+
+    def self.maybe_create_or_update_cloudfront(options, standard_input)
+      unless user_already_has_cf_configured options
+        CloudFrontClient.create_distribution_if_user_agrees options, standard_input
+        return
+      end
+      if user_already_has_cf_configured(options) and user_has_custom_cf_dist_config(options)
+        CloudFrontClient.apply_distribution_config options
+        return
+      end
+    end
+
+    def self.user_already_has_cf_configured(options)
+      config_source = options[:config_source]
+      config_source.cloudfront_distribution_id
+    end
+
+    def self.user_has_custom_cf_dist_config(options)
+      config_source = options[:config_source]
+      config_source.cloudfront_distribution_config
+    end
+  end
+end

data/lib/configure-s3-website/s3_client.rb

@@ -0,0 +1,129 @@
+require 'base64'
+require 'openssl'
+require 'digest/sha1'
+require 'digest/md5'
+require 'net/https'
+require 'aws-sdk'
+
+module ConfigureS3Website
+  class S3Client
+    def self.configure_website(options)
+      config_source = options[:config_source]
+      begin
+        enable_website_configuration(config_source)
+        make_bucket_readable_to_everyone(config_source)
+      rescue Aws::S3::Errors::NoSuchBucket
+        create_bucket(config_source)
+        retry
+      end
+    end
+
+    private
+
+    def self.s3(config_source)
+      if config_source.s3_access_key_id
+        Aws::S3::Client.new(
+          region: config_source.s3_endpoint,
+          access_key_id: config_source.s3_access_key_id,
+          secret_access_key: config_source.s3_secret_access_key
+        )
+      elsif config_source.profile
+        Aws::S3::Client.new(
+          region: config_source.s3_endpoint,
+          profile: config_source.profile,
+        )
+      else
+        Aws::S3::Client.new(
+          region: config_source.s3_endpoint,
+        )
+      end
+    end
+
+    def self.enable_website_configuration(config_source)
+      routing_rules =
+        if config_source.routing_rules && config_source.routing_rules.is_a?(Array)
+          config_source.routing_rules.map { |rule|
+            Hash[
+              rule.map { |rule_key, rule_value|
+                [
+                  rule_key.to_sym,
+                  Hash[ # Assume that each rule value is a Hash
+                    rule_value.map { |redirect_rule_key, redirect_rule_value|
+                      [
+                        redirect_rule_key.to_sym,
+                        redirect_rule_key == "http_redirect_code" || redirect_rule_key == "http_error_code_returned_equals" ?
+                          redirect_rule_value.to_s
+                          #redirect_rule_value.to_s  # Permit numeric redirect values in the YAML config file. (The S3 API does not allow numeric redirect values, hence this block of code.)
+                          :
+                          redirect_rule_value
+                      ]
+                    }
+                  ]
+                ]
+              }
+            ]
+          }
+        else
+          nil
+        end
+      s3(config_source).put_bucket_website({
+        bucket: config_source.s3_bucket_name,
+        website_configuration: {
+          index_document: {
+            suffix: config_source.index_document || "index.html"
+          },
+          error_document: {
+            key: config_source.error_document || "error.html"
+          },
+          routing_rules: routing_rules
+        }
+      })
+      puts "Bucket #{config_source.s3_bucket_name} now functions as a website"
+      if routing_rules && routing_rules.any?
+        puts "#{routing_rules.size} redirects configured for #{config_source.s3_bucket_name} bucket"
+      else
+        puts "No redirects to configure for #{config_source.s3_bucket_name} bucket"
+      end
+    end
+
+    def self.make_bucket_readable_to_everyone(config_source)
+      s3(config_source).delete_public_access_block({
+        bucket: config_source.s3_bucket_name
+      })
+      s3(config_source).put_bucket_policy({
+        bucket: config_source.s3_bucket_name,
+        policy: %|{
+          "Version":"2008-10-17",
+          "Statement":[{
+            "Sid":"PublicReadForGetBucketObjects",
+            "Effect":"Allow",
+            "Principal": { "AWS": "*" },
+            "Action":["s3:GetObject"],
+            "Resource":["arn:aws:s3:::#{config_source.s3_bucket_name}/*"]
+          }]
+        }|
+      })
+      puts "Bucket #{config_source.s3_bucket_name} is now readable to the whole world"
+    end
+
+    def self.create_bucket(config_source)
+      s3(config_source).create_bucket({
+        bucket: config_source.s3_bucket_name,
+        create_bucket_configuration: 
+        if config_source.s3_endpoint && config_source.s3_endpoint != 'us-east-1'
+          {
+            location_constraint: config_source.s3_endpoint
+          }
+        else
+          nil
+        end
+      })
+      puts "Created bucket %s in the %s Region" %
+        [
+          config_source.s3_bucket_name,
+          config_source.s3_endpoint
+        ]
+    end
+  end
+end
+

data/lib/configure-s3-website/version.rb

@@ -0,0 +1,3 @@
+module ConfigureS3Website
+  VERSION = '3.0.0'
+end

data/lib/configure-s3-website/xml_helper.rb

@@ -0,0 +1,15 @@
+module ConfigureS3Website
+  class XmlHelper
+    def self.hash_to_api_xml(hash={}, indent=0)
+      "".tap do |body|
+        hash.each do |key, value|
+          key_name = key.sub(/^[a-z\d]*/) { $&.capitalize }.gsub(/(?:_|(\/))([a-z\d]*)/) { $2.capitalize }
+          value = value.is_a?(Hash) ? self.hash_to_api_xml(value, indent+1) : value
+          body << "\n"
+          body << " " * indent * 2 # 2-space indentation formatting for xml
+          body << "<#{key_name}>#{value}</#{key_name}>"
+        end
+      end
+    end
+  end
+end

data/lib/configure-s3-website.rb

@@ -0,0 +1,10 @@
+require 'configure-s3-website/version'
+require 'configure-s3-website/s3_client'
+require 'configure-s3-website/cloudfront_client'
+require 'configure-s3-website/xml_helper'
+require 'configure-s3-website/http_helper'
+require 'configure-s3-website/endpoint_helper'
+require 'configure-s3-website/runner'
+require 'configure-s3-website/cli'
+require 'configure-s3-website/config_source/config_source'
+require 'configure-s3-website/config_source/file_config_source'