middleman-core 3.4.1 → 4.0.0.alpha.2

data/lib/middleman-core/dns_resolver.rb

@@ -1,73 +0,0 @@
-require 'resolv'
-require 'middleman-core/dns_resolver/network_resolver'
-require 'middleman-core/dns_resolver/hosts_resolver'
-
-module Middleman
-  # This resolves IP address to names and vice versa
-  class DnsResolver
-    private
-
-    attr_reader :resolvers
-
-    public
-
-    # Create resolver
-    #
-    # First the local resolver is used. If environment variable HOSTSRC is
-    # given this file is used for local name lookup.
-    #
-    # @param [#getnames, #getaddresses] network_resolver
-    #   The resolver which uses a network name server to resolve ip addresses
-    #   and names.
-    #
-    # @param [#getnames, #getaddresses] local_resolver
-    #   The resolver uses /etc/hosts on POSIX-systems and
-    #   C:\Windows\System32\drivers\etc\hosts on Windows-operating systems to
-    #   resolve ip addresses and names.
-    #
-    # First the local resolver is queried. If this raises an error or returns
-    # nil or [] the network resolver is queried.
-    def initialize(opts={})
-      @resolvers = []
-      @resolvers << opts.fetch(:hosts_resolver, HostsResolver.new)
-
-      if RUBY_VERSION >= '2.1'
-        require 'middleman-core/dns_resolver/local_link_resolver'
-        @resolvers << opts.fetch(:local_link_resolver, LocalLinkResolver.new)
-      end
-
-      @resolvers << opts.fetch(:network_resolver, NetworkResolver.new)
-    end
-
-    # Get names for given ip
-    #
-    # @param [String] ip
-    #   The ip which should be resolved.
-    def names_for(ip)
-      resolvers.each do |r|
-        names = r.getnames(ip)
-
-        return names unless names.nil? || names.empty?
-      end
-
-      []
-    end
-
-    # Get ips for given name
-    #
-    # First the local resolver is used. On POSIX-systems /etc/hosts is used. On
-    # Windows C:\Windows\System32\drivers\etc\hosts is used.
-    #
-    # @param [String] name
-    #   The name which should be resolved.
-    def ips_for(name)
-      resolvers.each do |r|
-        ips = r.getaddresses(name)
-
-        return ips unless ips.nil? || ips.empty?
-      end
-
-      []
-    end
-  end
-end

data/lib/middleman-core/dns_resolver/basic_network_resolver.rb

@@ -1,52 +0,0 @@
-module Middleman
-  class DnsResolver
-    # Use network name server to resolve ips and names
-    class BasicNetworkResolver
-      private
-
-      attr_reader :resolver, :timeouts
-
-      public
-
-      def initialize(opts={})
-        @timeouts = opts.fetch(:timeouts, 2)
-      end
-
-      # Get names for ip
-      #
-      # @param [#to_s] ip
-      #   The ip to resolve into names
-      #
-      # @return [Array]
-      #   Array of Names
-      def getnames(ip)
-        resolver.getnames(ip.to_s).map(&:to_s)
-      rescue Resolv::ResolvError, Errno::EADDRNOTAVAIL, Errno::ENETUNREACH
-        []
-      end
-
-      # Get ips for name
-      #
-      # @param [#to_s] name
-      #   The name to resolve into ips
-      #
-      # @return [Array]
-      #   Array of ipaddresses
-      def getaddresses(name)
-        resolver.getaddresses(name.to_s).map(&:to_s)
-      rescue Resolv::ResolvError, Errno::EADDRNOTAVAIL, Errno::ENETUNREACH
-        []
-      end
-
-      # Set timeout for lookup
-      #
-      # @param [Integer] value
-      #   The timeout value
-      def timeouts=(timeouts)
-        return if RUBY_VERSION < '2'
-
-        resolver.timeouts = timeouts
-      end
-    end
-  end
-end

data/lib/middleman-core/dns_resolver/hosts_resolver.rb

@@ -1,63 +0,0 @@
-module Middleman
-  class DnsResolver
-    # Use network name server to resolve ips and names
-    class HostsResolver
-      private
-
-      attr_reader :resolver
-
-      public
-
-      def initialize(opts={})
-        # using the splat operator works around a non-existing HOSTSRC variable
-        # using nil as input does not work, but `*[]` does and then Resolv::Hosts
-        # uses its defaults
-        @resolver = opts.fetch(:resolver, Resolv::Hosts.new(*hosts_file))
-      end
-
-      # Get names for ip
-      #
-      # @param [#to_s] ip
-      #   The ip to resolve into names
-      #
-      # @return [Array]
-      #   Array of Names
-      def getnames(ip)
-        resolver.getnames(ip.to_s).map(&:to_s)
-      rescue Resolv::ResolvError
-        []
-      end
-
-      # Get ips for name
-      #
-      # @param [#to_s] name
-      #   The name to resolve into ips
-      #
-      # @return [Array]
-      #   Array of ipaddresses
-      def getaddresses(name)
-        resolver.getaddresses(name.to_s).map(&:to_s)
-      rescue Resolv::ResolvError
-        []
-      end
-
-      private
-
-      # Path to hosts file
-      #
-      # This looks for MM_HOSTSRC in your environment
-      #
-      # @return [Array]
-      #   This needs to be an array, to make the splat operator work
-      #
-      # @example
-      #   # <ip> <hostname>
-      #   127.0.0.1 localhost.localhost localhost
-      def hosts_file
-        return [ENV['MM_HOSTSRC']] if ENV.key?('MM_HOSTSRC') && File.file?(ENV['MM_HOSTSRC'])
-
-        []
-      end
-    end
-  end
-end

data/lib/middleman-core/dns_resolver/local_link_resolver.rb

@@ -1,44 +0,0 @@
-require 'middleman-core/dns_resolver/basic_network_resolver'
-
-module Middleman
-  class DnsResolver
-    # Use network name server to resolve ips and names
-    class LocalLinkResolver < BasicNetworkResolver
-      def initialize(opts={})
-        super
-
-        @timeouts = opts.fetch(:timeouts, 1)
-        @resolver = opts.fetch(:resolver, Resolv::MDNS.new(nameserver_config))
-
-        self.timeouts = timeouts
-      end
-
-      private
-
-      # Hosts + Ports for MDNS resolver
-      #
-      # This looks for MM_MDNSRC in your environment. If you are going to use
-      # IPv6-addresses: Make sure you do not forget to add the port at the end.
-      #
-      # MM_MDNSRC=ip:port ip:port
-      #
-      # @return [Hash]
-      #   Returns the configuration for the nameserver
-      #
-      # @example
-      #   export MM_MDNSRC="224.0.0.251:5353 ff02::fb:5353"
-      #
-      def nameserver_config
-        return unless ENV.key?('MM_MDNSRC') && ENV['MM_MDNSRC']
-
-        address, port = ENV['MM_MDNSRC'].split(/:/)
-
-        {
-          nameserver_port: [[address, port.to_i]]
-        }
-      rescue StandardError
-        {}
-      end
-    end
-  end
-end

data/lib/middleman-core/dns_resolver/network_resolver.rb

@@ -1,42 +0,0 @@
-require 'middleman-core/dns_resolver/basic_network_resolver'
-
-module Middleman
-  class DnsResolver
-    # Use network name server to resolve ips and names
-    class NetworkResolver < BasicNetworkResolver
-      def initialize(opts={})
-        super
-
-        @resolver = opts.fetch(:resolver, Resolv::DNS.new(nameserver_config))
-        self.timeouts = timeouts
-      end
-
-      private
-
-      # Hosts + Ports for MDNS resolver
-      #
-      # This looks for MM_MDNSRC in your environment. If you are going to use
-      # IPv6-addresses: Make sure you do not forget to add the port at the end.
-      #
-      # MM_MDNSRC=ip:port ip:port
-      #
-      # @return [Hash]
-      #   Returns the configuration for the nameserver
-      #
-      # @example
-      #   export MM_MDNSRC="224.0.0.251:5353 ff02::fb:5353"
-      #
-      def nameserver_config
-        return unless ENV.key?('MM_DNSRC') && ENV['MM_DNSRC']
-
-        address, port = ENV['MM_DNSRC'].split(/:/)
-
-        {
-          nameserver_port: [[address, port.to_i]]
-        }
-      rescue StandardError
-        {}
-      end
-    end
-  end
-end

data/lib/middleman-core/preview_server/checks.rb

@@ -1,81 +0,0 @@
-require 'ipaddr'
-
-module Middleman
-  class PreviewServer
-    # Checks for input of preview server
-    module Checks
-      # This one will get all default setup
-      class BasicCheck; end
-
-      # This checks if the server name resolves to the bind_address
-      #
-      # If the users enters:
-      #
-      # 1. server_name: www.example.com (10.0.0.1)
-      # 2. bind_address: 127.0.0.01
-      #
-      # This validation will fail
-      class ServerNameResolvesToBindAddress < BasicCheck
-        private
-
-        attr_reader :resolver
-
-        public
-
-        def initialize
-          @resolver = DnsResolver.new
-        end
-
-        # Validate
-        #
-        # @param [Information] information
-        #   The information to be validated
-        def validate(information)
-          return if  resolver.ips_for(information.server_name).include? information.bind_address
-
-          information.valid = false
-          information.reason = format('Server name "%s" does not resolve to bind address "%s"', information.server_name, information.bind_address)
-        end
-      end
-
-      # This validation fails if the user chooses to use an ip address which is
-      # not available on his/her system
-      class InterfaceIsAvailableOnSystem < BasicCheck
-        # Validate
-        #
-        # @param [Information] information
-        #   The information to be validated
-        def validate(information)
-          return if information.bind_address.blank? || information.local_network_interfaces.include?(information.bind_address.to_s) || %w(0.0.0.0 ::).any? { |b| information.bind_address == b } || IPAddr.new('127.0.0.0/8').include?(information.bind_address.to_s)
-
-          information.valid = false
-          information.reason = format('Bind address "%s" is not available on your system. Please use one of %s', information.bind_address, information.local_network_interfaces.map { |i| %("#{i}") }.join(', '))
-        end
-      end
-
-      # This one requires a bind address if the user entered a server name
-      #
-      # If the `bind_address` is blank this check will fail
-      class RequiresBindAddressIfServerNameIsGiven < BasicCheck
-        def validate(information)
-          return unless information.bind_address.blank?
-
-          information.valid = false
-          information.reason = format('Server name "%s" does not resolve to an ip address', information.server_name)
-        end
-      end
-
-      # This validation always fails
-      class DenyAnyAny < BasicCheck
-        # Validate
-        #
-        # @param [Information] information
-        #   The information to be validated
-        def validate(information)
-          information.valid = false
-          information.reason = 'Undefined combination of options "--server-name" and "--bind-address". If you think this is wrong, please file a bug at "https://github.com/middleman/middleman"'
-        end
-      end
-    end
-  end
-end

data/lib/middleman-core/preview_server/information.rb

@@ -1,273 +0,0 @@
-require 'ipaddr'
-require 'active_support/core_ext/object/blank'
-require 'middleman-core/preview_server/checks'
-require 'middleman-core/preview_server/server_hostname'
-require 'middleman-core/preview_server/server_ip_address'
-
-module Middleman
-  class PreviewServer
-    # Basic information class to wrap common behaviour
-    class BasicInformation
-      private
-
-      attr_reader :checks, :network_interfaces_inventory
-
-      public
-
-      attr_accessor :bind_address, :server_name, :port, :reason, :valid
-      attr_reader :listeners, :site_addresses
-
-      # Create instance
-      #
-      # @param [String] bind_address
-      #   The bind address of the server
-      #
-      # @param [String] server_name
-      #   The name of the server
-      #
-      # @param [Integer] port
-      #   The port to listen on
-      def initialize(opts={})
-        @bind_address = ServerIpAddress.new(opts[:bind_address])
-        @server_name  = ServerHostname.new(opts[:server_name])
-        @port         = opts[:port]
-        @valid        = true
-
-        @site_addresses = []
-        @listeners = []
-        @checks = []
-
-        # This needs to be check for each use case. Otherwise `Webrick` will
-        # complain about that.
-        @checks << Checks::InterfaceIsAvailableOnSystem.new
-      end
-
-      # Is the given information valid?
-      def valid?
-        valid == true
-      end
-
-      # Pass "self" to validator
-      #
-      # @param [#validate] validator
-      #   The validator
-      def validate_me(validator)
-        validator.validate self, checks
-      end
-
-      def resolve_me(*)
-        fail NoMethodError
-      end
-
-      # Get network information
-      #
-      # @param [#network_interfaces] inventory
-      #   Get list of available network interfaces
-      def show_me_network_interfaces(inventory)
-        @network_interfaces_inventory = inventory
-      end
-
-      # Default is to get all network interfaces
-      def local_network_interfaces
-        network_interfaces_inventory.nil? ? [] : network_interfaces_inventory.network_interfaces(:all)
-      end
-    end
-
-    # This only is used if no other parser is available
-    #
-    # The "default" behaviour is to fail because of "Checks::DenyAnyAny"
-    class DefaultInformation < BasicInformation
-      def initialize(*args)
-        super
-
-        # Make this fail
-        @checks << Checks::DenyAnyAny.new
-      end
-
-      def resolve_me(*); end
-
-      # Always true
-      def self.matches?(*)
-        true
-      end
-    end
-
-    # This one is used if no bind address and no server name is given
-    class AllInterfaces < BasicInformation
-      def initialize(*args)
-        super
-
-        after_init
-      end
-
-      def self.matches?(opts={})
-        opts[:bind_address].blank? && opts[:server_name].blank?
-      end
-
-      # Resolve ips
-      def resolve_me(resolver)
-        hostname          = ServerHostname.new(Socket.gethostname)
-        hostname_ips      = resolver.ips_for(hostname)
-        network_interface = ServerIpAddress.new(Array(local_network_interfaces).first)
-        resolved_name     = ServerHostname.new(resolver.names_for(network_interface).first)
-
-        if includes_array? local_network_interfaces, hostname_ips
-          @server_name = hostname
-          @site_addresses << hostname
-
-          network_interface = ServerIpAddress.new((local_network_interfaces & hostname_ips).first)
-        elsif RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
-          @server_name = hostname
-          @site_addresses << hostname
-        elsif !resolved_name.blank?
-          @server_name = resolved_name
-          @site_addresses << resolved_name
-        else
-          @server_name = network_interface
-        end
-
-        @site_addresses << network_interface
-
-        self
-      end
-
-      private
-
-      def includes_array?(a, b)
-        !(a & b).empty?
-      end
-
-      def after_init
-        @listeners << ServerIpAddress.new('::')
-        @listeners << ServerIpAddress.new('0.0.0.0')
-      end
-    end
-
-    # This is used if bind address is 0.0.0.0, the server name needs to be
-    # blank
-    class AllIpv4Interfaces < AllInterfaces
-      def self.matches?(opts={})
-        opts[:bind_address] == '0.0.0.0' && opts[:server_name].blank?
-      end
-
-      # Use only ipv4 interfaces
-      def local_network_interfaces
-        network_interfaces_inventory.nil? ? [] : network_interfaces_inventory.network_interfaces(:ipv4)
-      end
-
-      private
-
-      def after_init
-        @listeners << ServerIpAddress.new('0.0.0.0')
-      end
-    end
-
-    # This is used if bind address is ::, the server name needs to be blank
-    class AllIpv6Interfaces < AllInterfaces
-      def self.matches?(opts={})
-        opts[:bind_address] == '::' && opts[:server_name].blank?
-      end
-
-      # Use only ipv6 interfaces
-      def local_network_interfaces
-        network_interfaces_inventory.nil? ? [] : network_interfaces_inventory.network_interfaces(:ipv6)
-      end
-
-      private
-
-      def after_init
-        @listeners << ServerIpAddress.new('::')
-      end
-    end
-
-    # Used if a bind address is given and the server name is blank
-    class BindAddressInformation < BasicInformation
-      def initialize(*args)
-        super
-
-        @listeners << bind_address
-        @site_addresses << bind_address
-      end
-
-      def self.matches?(opts={})
-        !opts[:bind_address].blank? && opts[:server_name].blank?
-      end
-
-      # Resolv
-      def resolve_me(resolver)
-        @server_name = ServerHostname.new(resolver.names_for(bind_address).first)
-        @site_addresses << @server_name unless @server_name.blank?
-
-        self
-      end
-    end
-
-    # Use if server name is given and bind address is blank
-    class ServerNameInformation < BasicInformation
-      def initialize(*args)
-        super
-
-        @checks << Checks::RequiresBindAddressIfServerNameIsGiven.new
-        @site_addresses << server_name
-      end
-
-      def resolve_me(resolver)
-        @bind_address = ServerIpAddress.new(resolver.ips_for(server_name).first)
-
-        unless bind_address.blank?
-          @listeners << bind_address
-          @site_addresses << bind_address
-        end
-
-        self
-      end
-
-      def self.matches?(opts={})
-        opts[:bind_address].blank? && !opts[:server_name].blank?
-      end
-    end
-
-    # Only used if bind address and server name are given and bind address is
-    # not :: or 0.0.0.0
-    class BindAddressAndServerNameInformation < BasicInformation
-      def initialize(*args)
-        super
-
-        @listeners << bind_address
-        @site_addresses << server_name
-        @site_addresses << bind_address
-
-        @checks << Checks::ServerNameResolvesToBindAddress.new
-      end
-
-      def self.matches?(opts={})
-        !opts[:bind_address].blank? && !opts[:server_name].blank? && !%w(:: 0.0.0.0).include?(opts[:bind_address])
-      end
-
-      def resolve_me(*); end
-    end
-
-    # If the server name is either an ipv4 or ipv6 address, e.g. 127.0.0.1 or
-    # ::1, use this one
-    class ServerNameIsIpInformation < BasicInformation
-      def initialize(opts={})
-        super
-
-        ip = ServerIpAddress.new(server_name.to_s)
-
-        @listeners << ip
-        @site_addresses << ip
-      end
-
-      def resolve_me(*); end
-
-      def self.matches?(opts={})
-        ip = IPAddr.new(opts[:server_name])
-
-        ip.ipv4? || ip.ipv6?
-      rescue
-        false
-      end
-    end
-  end
-end