embargoed 2.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c4f9b6c54838896e47c825725907170322148c1bf40351d0e4607b5375037e98
+  data.tar.gz: 63e544b02169e811de9547fd1bf95a4008df0faaaa5e5fdf51efbdfb253b5d18
+SHA512:
+  metadata.gz: 2a3a1062c73c4014abb13f1077587831b98a17e77675e806b567f165f6bf352538b929ab2a01c15a0958004f90c7716d7e74cf63b232da3e646aaa805cae7b6d
+  data.tar.gz: 4183a31830ffee4d535f8a35b49681318462d8afe416d330bf3a5d8cf01466cd60c6679c69a3689779584efe048335cf9e09fd32e1819a5a123e3e1e314b2e8d

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 by Biola University
+
+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.

data/README.md

@@ -0,0 +1,27 @@
+Embargoed
+=======
+Embargoed is [Rack](http://rack.rubyforge.org/) middleware with a [Ruby on Rails](http://rubyonrails.org) engine that blocks all requests from Russia and displays a pro-Ukraine message instead.
+
+Embargoed is a fork from [Turnout](https://github.com/biola/turnout).
+
+![Embargoed message displayed to Russian visitors](https://github.com/rameerez/embargoed/blob/main/public/embargoed-message.jpg?raw=true)
+
+
+## Installation
+
+Add this to your `Gemfile`:
+
+    gem 'embargoed'
+
+then run
+
+    bundle install
+    
+_Note that you'll need to restart your Rails server before it works_
+
+That's it! Just by having `embargoed` on your Gemfile your Rails app will display this message to all requests from a Russian IP.
+
+
+## Collaborate
+
+Please feel free to contact me [@rameerez](https://twitter.com/rameerez) or fork this to port it to other platforms, or make PRs to this repo to collaborate.

data/lib/embargoed/configuration.rb

@@ -0,0 +1,60 @@
+require_relative './ordered_options'
+module Embargoed
+  class Configuration
+    SETTINGS = [
+      :app_root,
+      :named_maintenance_file_paths,
+      :maintenance_pages_path,
+      :default_maintenance_page,
+      :default_reason,
+      :default_allowed_ips,
+      :skip_middleware,
+      :default_allowed_paths,
+      :default_response_code,
+      :default_retry_after,
+      :i18n
+    ].freeze
+
+    SETTINGS.each do |setting|
+      attr_accessor setting
+    end
+
+    def initialize
+      @skip_middleware = false
+      @app_root = '.'
+      @named_maintenance_file_paths = {default: app_root.join('tmp', 'maintenance.yml').to_s}
+      @maintenance_pages_path = app_root.join('public').to_s
+      @default_maintenance_page = Embargoed::MaintenancePage::HTML
+      @default_reason = "The site is temporarily down for maintenance.\nPlease check back soon."
+      @default_allowed_paths = []
+      @default_allowed_ips = []
+      @default_response_code = 503
+      @default_retry_after = 7200 # 2 hours by default
+      @i18n = Embargoed::OrderedOptions.new
+      @i18n.railties_load_path = []
+      @i18n.load_path = []
+      @i18n.fallbacks = Embargoed::OrderedOptions.new
+      @i18n.enabled = false
+      @i18n.use_language_header = false
+    end
+
+    def app_root
+      Pathname.new(@app_root.to_s)
+    end
+
+    def named_maintenance_file_paths=(named_paths)
+      # Force keys to symbols
+      @named_maintenance_file_paths = Hash[named_paths.map { |k, v| [k.to_sym, v] }]
+    end
+
+    def update(settings_hash)
+      settings_hash.each do |setting, value|
+        unless SETTINGS.include? setting.to_sym
+          raise ArgumentError, "invalid setting: #{setting}"
+        end
+
+        self.public_send "#{setting}=", value
+      end
+    end
+  end
+end

data/lib/embargoed/engine.rb

@@ -0,0 +1,16 @@
+require 'embargoed'
+require 'rack/embargoed'
+require 'rails'
+
+# For Rails 3
+if defined? Rails::Engine
+  module Embargoed
+    class Engine < Rails::Engine
+      initializer 'embargoed.add_to_middleware_stack' do |app|
+        unless Embargoed.config.skip_middleware
+          app.config.middleware.use(Rack::Embargoed)
+        end
+      end
+    end
+  end
+end

data/lib/embargoed/i18n/accept_language_parser.rb

@@ -0,0 +1,109 @@
+module Embargoed
+  class AcceptLanguageParser
+    attr_accessor :header
+
+    def initialize(header)
+      @header = header
+    end
+
+    # Returns a sorted array based on user preference in HTTP_ACCEPT_LANGUAGE.
+    # Browsers send this HTTP header, so don't think this is holy.
+    #
+    # Example:
+    #
+    #   request.user_preferred_languages
+    #   # => [ 'nl-NL', 'nl-BE', 'nl', 'en-US', 'en' ]
+    #
+    def user_preferred_languages
+      return [] if header.to_s.strip.empty?
+      @user_preferred_languages ||= begin
+        header.to_s.gsub(/\s+/, '').split(',').map do |language|
+          locale, quality = language.split(';q=')
+          raise ArgumentError, 'Not correctly formatted' unless locale =~ /^[a-z\-0-9]+|\*$/i
+
+          locale  = locale.downcase.gsub(/-[a-z0-9]+$/i, &:upcase) # Uppercase territory
+          locale  = nil if locale == '*' # Ignore wildcards
+
+          quality = quality ? quality.to_f : 1.0
+
+          [locale, quality]
+        end.sort do |(_, left), (_, right)|
+          right <=> left
+        end.map(&:first).compact
+      rescue ArgumentError # Just rescue anything if the browser messed up badly.
+        []
+      end
+    end
+
+    # Sets the user languages preference, overriding the browser
+    #
+    def user_preferred_languages=(languages)
+      @user_preferred_languages = languages
+    end
+
+    # Finds the locale specifically requested by the browser.
+    #
+    # Example:
+    #
+    #   request.preferred_language_from I18n.available_locales
+    #   # => 'nl'
+    #
+    def preferred_language_from(array)
+      (user_preferred_languages & array.map(&:to_s)).first
+    end
+
+    # Returns the first of the user_preferred_languages that is compatible
+    # with the available locales. Ignores region.
+    #
+    # Example:
+    #
+    #   request.compatible_language_from I18n.available_locales
+    #
+    def compatible_language_from(available_languages)
+      user_preferred_languages.map do |preferred| #en-US
+        preferred = preferred.downcase
+        preferred_language = preferred.split('-', 2).first
+
+        available_languages.find do |available| # en
+          available = available.to_s.downcase
+          preferred == available || preferred_language == available.split('-', 2).first
+        end
+      end.compact.first
+    end
+
+    # Returns a supplied list of available locals without any extra application info
+    # that may be attached to the locale for storage in the application.
+    #
+    # Example:
+    # [ja_JP-x1, en-US-x4, en_UK-x5, fr-FR-x3] => [ja-JP, en-US, en-UK, fr-FR]
+    #
+    def sanitize_available_locales(available_languages)
+      available_languages.map do |available|
+        available.to_s.split(/[_-]/).reject { |part| part.start_with?("x") }.join("-")
+      end
+    end
+
+    # Returns the first of the user preferred languages that is
+    # also found in available languages.  Finds best fit by matching on
+    # primary language first and secondarily on region.  If no matching region is
+    # found, return the first language in the group matching that primary language.
+    #
+    # Example:
+    #
+    #   request.language_region_compatible(available_languages)
+    #
+    def language_region_compatible_from(available_languages)
+      available_languages = sanitize_available_locales(available_languages)
+      user_preferred_languages.map do |preferred| #en-US
+        preferred = preferred.downcase
+        preferred_language = preferred.split('-', 2).first
+
+        lang_group = available_languages.select do |available| # en
+          preferred_language == available.downcase.split('-', 2).first
+        end
+
+        lang_group.find { |lang| lang.downcase == preferred } || lang_group.first #en-US, en-UK
+      end.compact.first
+    end
+  end
+end

data/lib/embargoed/i18n/internationalization.rb

@@ -0,0 +1,141 @@
+require 'i18n'
+require 'i18n/backend/fallbacks'
+require_relative './accept_language_parser'
+require_relative '../ordered_options'
+
+module Embargoed
+  class Internationalization
+    class << self
+      attr_reader :env
+      attr_writer :env
+
+      def initialize_i18n(env)
+        @env = env
+        setup_i18n_config
+      end
+
+      def i18n_config
+        @i18n_config = Embargoed.config.i18n
+        @i18n_config =  @i18n_config.is_a?(Embargoed::OrderedOptions) ? @i18n_config : Embargoed::InheritableOptions.new(@i18n_config)
+      end
+
+      def embargoed_page
+        @embargoed_page ||= Embargoed.config.default_maintenance_page
+      end
+
+      def http_accept_language
+        language = (env.nil? || env.empty?) ? nil : env["HTTP_ACCEPT_LANGUAGE"]
+        @http_accept_language ||= Embargoed::AcceptLanguageParser.new(language)
+      end
+
+      def setup_additional_helpers
+        i18n_additional_helpers = i18n_config.delete(:additional_helpers)
+        i18n_additional_helpers = i18n_additional_helpers.is_a?(Array) ? i18n_additional_helpers : []
+
+        i18n_additional_helpers.each do |helper|
+          embargoed_page.send(:include, helper) if helper.is_a?(Module)
+        end
+      end
+
+      def expanded(path)
+        result = []
+        if File.directory?(path)
+          result.concat(Dir.glob(File.join(path, '**', '**')).map { |file| file }.sort)
+        else
+          result << path
+        end
+        result.uniq!
+        result
+      end
+
+      # Returns all expanded paths but only if they exist in the filesystem.
+      def existent(path)
+        expanded(path).select { |f| File.exist?(f) }
+      end
+
+      # Setup i18n configuration.
+      def setup_i18n_config
+        return unless i18n_config.enabled
+        setup_additional_helpers
+        fallbacks = i18n_config.delete(:fallbacks)
+
+
+        # Avoid issues with setting the default_locale by disabling available locales
+        # check while configuring.
+        enforce_available_locales = i18n_config.delete(:enforce_available_locales)
+        enforce_available_locales = I18n.enforce_available_locales if enforce_available_locales.nil?
+        I18n.enforce_available_locales = false
+
+        i18n_config.except(:enabled, :use_language_header).each do |setting, value|
+          case setting
+          when :railties_load_path
+            I18n.load_path.unshift(*value.map { |file| existent(file) }.flatten)
+          when :load_path
+            I18n.load_path += value
+          else
+            I18n.send("#{setting}=", value)
+          end
+        end
+
+
+        init_fallbacks(fallbacks) if fallbacks && validate_fallbacks(fallbacks)
+        I18n.backend.load_translations
+
+        # Restore available locales check so it will take place from now on.
+        I18n.enforce_available_locales = enforce_available_locales
+
+        begin
+          if i18n_config.use_language_header
+            I18n.locale = http_accept_language.compatible_language_from(I18n.available_locales) || I18n.default_locale
+          else
+            I18n.locale = I18n.default_locale
+          end
+        rescue
+          #nothing
+        end
+
+      end
+
+      def array_wrap(object)
+        if object.nil?
+          []
+        elsif object.respond_to?(:to_ary)
+          object.to_ary || [object]
+        else
+          [object]
+        end
+      end
+
+      def include_fallbacks_module
+        I18n.backend.class.send(:include, I18n::Backend::Fallbacks)
+      end
+
+      def init_fallbacks(fallbacks)
+        include_fallbacks_module
+
+        args = case fallbacks
+        when Embargoed::OrderedOptions
+          [*(fallbacks[:defaults] || []) << fallbacks[:map]].compact
+        when Hash, Array
+          array_wrap(fallbacks)
+        else # TrueClass
+          []
+        end
+
+        I18n.fallbacks = I18n::Locale::Fallbacks.new(*args)
+      end
+
+      def validate_fallbacks(fallbacks)
+        case fallbacks
+        when Embargoed::OrderedOptions
+          !fallbacks.empty?
+        when TrueClass, Array, Hash
+          true
+        else
+          raise "Unexpected fallback type #{fallbacks.inspect}"
+        end
+      end
+
+    end
+  end
+end

data/lib/embargoed/ip_locator.rb

@@ -0,0 +1,29 @@
+require 'maxmind/db'
+
+module Embargoed
+  class IPLocator
+
+    def self.get_country_code(ip)
+      country_code = "none"
+
+      # Using an Open-Source IP db released under an Apache2 license: https://github.com/geoacumen/geoacumen-country
+      db = File.expand_path("../../../public/Geoacumen-Country.mmdb", __FILE__)
+      reader = MaxMind::DB.new(db, mode: MaxMind::DB::MODE_MEMORY)
+
+      begin
+        record = reader.get(ip)
+      rescue => error
+        puts error.inspect
+      end
+
+      if !record.nil?
+        country_code = record['country']['iso_code']
+      end
+
+      reader.close
+
+      return country_code
+    end
+
+  end
+end

data/lib/embargoed/maintenance_file.rb

@@ -0,0 +1,119 @@
+require 'yaml'
+require 'fileutils'
+
+module Embargoed
+  class MaintenanceFile
+    attr_reader :path
+
+    SETTINGS = [:reason, :allowed_paths, :allowed_ips, :response_code, :retry_after]
+    attr_reader(*SETTINGS)
+
+    def initialize(path)
+      @path = path
+      @reason = Embargoed.config.default_reason
+      @allowed_paths = Embargoed.config.default_allowed_paths
+      @allowed_ips = Embargoed.config.default_allowed_ips
+      @response_code = Embargoed.config.default_response_code
+      @retry_after = Embargoed.config.default_retry_after
+
+      import_yaml if exists?
+    end
+
+    def exists?
+      File.exist? path
+    end
+
+    def to_h
+      SETTINGS.each_with_object({}) do |att, hash|
+        hash[att] = send(att)
+      end
+    end
+
+    def to_yaml(key_mapper = :to_s)
+      to_h.each_with_object({}) { |(key, val), hash|
+        hash[key.send(key_mapper)] = val
+      }.to_yaml
+    end
+
+    def write
+      FileUtils.mkdir_p(dir_path) unless Dir.exist? dir_path
+
+      File.open(path, 'w') do |file|
+        file.write to_yaml
+      end
+    end
+
+    def delete
+      File.delete(path) if exists?
+    end
+
+    def import(hash)
+      SETTINGS.map(&:to_s).each do |att|
+        self.send(:"#{att}=", hash[att]) unless hash[att].nil?
+      end
+
+      true
+    end
+    alias :import_env_vars :import
+
+    # Find the first MaintenanceFile that exists
+    def self.find
+      path = named_paths.values.find { |p| File.exist? p }
+      self.new(path) if path
+    end
+
+    def self.named(name)
+      path = named_paths[name.to_sym]
+      self.new(path) unless path.nil?
+    end
+
+    def self.default
+      self.new(named_paths.values.first)
+    end
+
+    private
+
+    def retry_after=(value)
+      @retry_after = value
+    end
+
+    def reason=(reason)
+      @reason = reason.to_s
+    end
+
+    # Splits strings on commas for easier importing of environment variables
+    def allowed_paths=(paths)
+      if paths.is_a? String
+        # Grab everything between commas that aren't escaped with a backslash
+        paths = paths.to_s.split(/(?<!\\),\ ?/).map do |path|
+          path.strip.gsub('\,', ',') # remove the escape characters
+        end
+      end
+
+      @allowed_paths = paths
+    end
+
+    # Splits strings on commas for easier importing of environment variables
+    def allowed_ips=(ips)
+      ips = ips.to_s.split(',') if ips.is_a? String
+
+      @allowed_ips = ips
+    end
+
+    def response_code=(code)
+      @response_code = code.to_i
+    end
+
+    def dir_path
+      File.dirname(path)
+    end
+
+    def import_yaml
+      import YAML::load(File.open(path)) || {}
+    end
+
+    def self.named_paths
+      Embargoed.config.named_maintenance_file_paths
+    end
+  end
+end

data/lib/embargoed/maintenance_page/base.rb

@@ -0,0 +1,79 @@
+module Embargoed
+  module MaintenancePage
+    class Base
+      attr_reader :reason
+
+      def initialize(reason = nil, options = {})
+        @options = options.is_a?(Hash) ? options : {}
+        @reason = reason
+      end
+
+      def rack_response(code = nil, retry_after = nil)
+        code ||= Embargoed.config.default_response_code
+        [code, headers(retry_after), body]
+      end
+
+      # Override with an array of media type strings. i.e. text/html
+      def self.media_types
+        raise NotImplementedError, '.media_types must be overridden in subclasses'
+      end
+      def media_types() self.class.media_types end
+
+      # Override with a file extension value like 'html' or 'json'
+      def self.extension
+        raise NotImplementedError, '.extension must be overridden in subclasses'
+      end
+      def extension() self.class.extension end
+
+      def custom_path
+        Pathname.new(Embargoed.config.maintenance_pages_path).join(filename)
+      end
+
+      protected
+
+      def self.inherited(subclass)
+        MaintenancePage.all << subclass
+      end
+
+      def headers(retry_after = nil)
+        headers = {'Content-Type' => media_types.first, 'Content-Length' => length}
+        # Include the Retry-After header unless it wasn't specified
+        headers['Retry-After'] = retry_after.to_s unless retry_after.nil?
+        headers
+      end
+
+      def length
+        content.bytesize.to_s
+      end
+
+      def body
+        [content]
+      end
+
+      def content
+         file_content.gsub(/{{\s?reason\s?}}/, reason)
+      end
+
+      def file_content
+        File.read(path)
+      end
+
+      def path
+        if File.exist? custom_path
+          custom_path
+        else
+          default_path
+        end
+      end
+
+      def default_path
+        File.expand_path("../../../../public/#{filename}", __FILE__)
+      end
+
+
+      def filename
+        "maintenance.#{extension}"
+      end
+    end
+  end
+end

data/lib/embargoed/maintenance_page/erb.rb

@@ -0,0 +1,22 @@
+require 'erb'
+require 'tilt'
+require 'tilt/erb'
+require_relative './html'
+require_relative '../i18n/internationalization'
+
+module Embargoed
+  module MaintenancePage
+    class Erb < Embargoed::MaintenancePage::HTML
+
+      def content
+        Embargoed::Internationalization.initialize_i18n(@options[:env])
+        Tilt.new(File.expand_path(path)).render(self, {reason: reason}.merge(@options))
+      end
+      
+      def self.extension
+        'html.erb'
+      end
+
+    end
+  end
+end

data/lib/embargoed/maintenance_page/html.rb

@@ -0,0 +1,21 @@
+require_relative './base'
+module Embargoed
+  module MaintenancePage
+    class HTML < Base
+      def reason
+        super.to_s.split("\n").map{|txt| "<p>#{txt}</p>" }.join("\n")
+      end
+
+      def self.media_types
+        %w{
+          text/html
+          application/xhtml+xml
+        }
+      end
+
+      def self.extension
+        'html'
+      end
+    end
+  end
+end

data/lib/embargoed/maintenance_page/json.rb

@@ -0,0 +1,26 @@
+require 'json'
+
+module Embargoed
+  module MaintenancePage
+    class JSON < Base
+      def reason
+        super.to_s.to_json
+      end
+
+      def self.media_types
+        %w{
+          application/json
+          text/json
+          application/x-javascript
+          text/javascript
+          text/x-javascript
+          text/x-json
+        }
+      end
+
+      def self.extension
+        'json'
+      end
+    end
+  end
+end