middleman-core 3.3.12 → 3.4.0

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

@@ -0,0 +1,273 @@
+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

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

@@ -0,0 +1,65 @@
+require 'middleman-core/preview_server/server_ip_address'
+
+module Middleman
+  class PreviewServer
+    # This holds information about local network interfaces on the user systemd
+    class NetworkInterfaceInventory
+      # Return all ip interfaces
+      class All
+        def network_interfaces
+          ipv4_addresses = Socket.ip_address_list.select(&:ipv4?).map { |ai| ServerIpv4Address.new(ai.ip_address) }
+          ipv6_addresses = Socket.ip_address_list.select(&:ipv6?).map { |ai| ServerIpv6Address.new(ai.ip_address) }
+
+          ipv4_addresses + ipv6_addresses
+        end
+
+        def self.match?(*)
+          true
+        end
+      end
+
+      # Return all ipv4 interfaces
+      class Ipv4
+        def network_interfaces
+          Socket.ip_address_list.select { |ai| ai.ipv4? && !ai.ipv4_loopback? }.map { |ai| ServerIpv4Address.new(ai.ip_address) }
+        end
+
+        def self.match?(type)
+          :ipv4 == type
+        end
+      end
+
+      # Return all ipv6 interfaces
+      class Ipv6
+        def network_interfaces
+          Socket.ip_address_list.select { |ai| ai.ipv6? && !ai.ipv6_loopback? }.map { |ai| ServerIpv6Address.new(ai.ip_address) }
+        end
+
+        def self.match?(type)
+          :ipv6 == type
+        end
+      end
+
+      private
+
+      attr_reader :types
+
+      public
+
+      def initialize
+        @types = []
+        @types << Ipv4
+        @types << Ipv6
+        @types << All
+      end
+
+      # Return ip interfaces
+      #
+      # @param [Symbol] type
+      #   The type of interface which should be returned
+      def network_interfaces(type=:all)
+        types.find { |t| t.match? type.to_sym }.new.network_interfaces
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module Middleman
+  class PreviewServer
+    class ServerHostname
+      class ServerFullHostname < SimpleDelegator
+        def to_s
+          __getobj__.gsub(/\s/, '+')
+        end
+
+        def self.match?(*)
+          true
+        end
+
+        alias_method :to_browser, :to_s
+      end
+
+      class ServerPlainHostname < SimpleDelegator
+        def to_s
+          __getobj__.gsub(/\s/, '+') + '.local'
+        end
+
+        def self.match?(name)
+          # rubocop:disable Style/CaseEquality
+          name != 'localhost' && /^(?=.{1,255}$)[0-9A-Za-z](?:(?:[0-9A-Za-z]|-){0,61}[0-9A-Za-z])?\.?$/ === name
+          # rubocop:enable Style/CaseEquality
+        end
+
+        alias_method :to_browser, :to_s
+      end
+
+      def self.new(string)
+        @names = []
+        @names << ServerPlainHostname
+        @names << ServerFullHostname
+
+        @names.find { |n| n.match? string }.new(string)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,144 @@
+require 'middleman-core/dns_resolver'
+require 'middleman-core/preview_server/information'
+require 'middleman-core/preview_server/network_interface_inventory'
+require 'middleman-core/preview_server/tcp_port_prober'
+require 'middleman-core/preview_server/server_information_validator'
+
+module Middleman
+  class PreviewServer
+    # This class holds all information which the preview server needs to setup a listener
+    #
+    # * server name
+    # * bind address
+    # * port
+    #
+    # Furthermore it probes for a free tcp port, if the default one 4567 is not available.
+    class ServerInformation
+      private
+
+      attr_reader :resolver, :validator, :network_interface_inventory, :informations, :tcp_port_prober
+
+      public
+
+      def initialize(opts={})
+        @resolver     = opts.fetch(:resolver, DnsResolver.new)
+        @validator    = opts.fetch(:validator, ServerInformationValidator.new)
+        @network_interface_inventory = opts.fetch(:network_interface_inventory, NetworkInterfaceInventory.new)
+        @tcp_port_prober = opts.fetch(:tcp_port_prober, TcpPortProber.new)
+
+        @informations = []
+        @informations << AllInterfaces
+        @informations << AllIpv4Interfaces
+        @informations << AllIpv6Interfaces
+        @informations << ServerNameIsIpInformation
+        @informations << ServerNameInformation
+        @informations << BindAddressInformation
+        @informations << BindAddressAndServerNameInformation
+        @informations << DefaultInformation
+      end
+
+      # The information
+      #
+      # Is cached
+      def information
+        return @information if @information
+
+        # The `DefaultInformation`-class always returns `true`, so there's
+        # always a klass available and find will never return nil
+        listener_klass = informations.find { |l| l.matches? bind_address: @bind_address, server_name: @server_name }
+        @information = listener_klass.new(bind_address: @bind_address, server_name: @server_name)
+
+        @information.show_me_network_interfaces(network_interface_inventory)
+        @information.resolve_me(resolver)
+        @information.port = tcp_port_prober.port(@port)
+        @information.validate_me(validator)
+
+        @information
+      end
+
+      # Use a middleman configuration to get information
+      #
+      # @param [#[]] config
+      #   The middleman config
+      def use(config)
+        @bind_address = config[:bind_address]
+        @port         = config[:port]
+        @server_name  = config[:server_name]
+
+        config[:bind_address] = bind_address
+        config[:port] = port
+        config[:server_name] = server_name
+      end
+
+      # Make information of internal server class avaible to make debugging
+      # easier. This can be used to log the class which was used to determine
+      # the preview server settings
+      #
+      # @return [String]
+      #   The name of the class
+      def handler
+        information.class.to_s
+      end
+
+      # Is the server information valid?
+      #
+      # This is used to output a helpful error message, which can be stored in
+      # `#reason`.
+      #
+      # @return [TrueClass, FalseClass]
+      #   The result
+      def valid?
+        information.valid?
+      end
+
+      # The reason why the information is NOT valid
+      #
+      # @return [String]
+      #   The reason why the information is not valid
+      def reason
+        information.reason
+      end
+
+      # The server name
+      #
+      # @return [String]
+      #   The name of the server
+      def server_name
+        information.server_name
+      end
+
+      # The bind address of server
+      #
+      # @return [String]
+      #   The bind address of the server
+      def bind_address
+        information.bind_address
+      end
+
+      # The port on which the server should listen
+      #
+      # @return [Integer]
+      #   The port number
+      def port
+        information.port
+      end
+
+      # A list of site addresses
+      #
+      # @return [Array]
+      #   A list of addresses which can be used to access the middleman preview
+      #   server
+      def site_addresses
+        information.site_addresses
+      end
+
+      # A list of listeners
+      #
+      # @return [Array]
+      #   A list of bind address where the
+      def listeners
+        information.listeners
+      end
+    end
+  end
+end