middleman-core 3.3.12 → 3.4.0

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

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

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

@@ -0,0 +1,42 @@
+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/extension.rb

@@ -130,7 +130,6 @@ module Middleman
       @klass.after_configuration do
         ext.after_configuration if ext.respond_to?(:after_configuration)
 
-        # rubocop:disable IfUnlessModifier
         if ext.respond_to?(:manipulate_resource_list)
           ext.app.sitemap.register_resource_list_manipulator(ext.class.extension_name, ext)
         end

data/lib/middleman-core/meta_pages.rb

@@ -90,7 +90,7 @@ module Middleman
       # Render a template with the given name and locals
       def template(template_name, locals={})
         template_path = File.join(File.dirname(__FILE__), 'meta_pages', 'templates', template_name)
-        content = Tilt.new(template_path).render(nil, locals)
+        content = Tilt.new(template_path).render(::Object.new, locals)
         response(content)
       end
 

data/lib/middleman-core/preview_server.rb

@@ -1,15 +1,16 @@
 require 'webrick'
 require 'webrick/https'
 require 'openssl'
-require 'socket'
 require 'middleman-core/meta_pages'
 require 'middleman-core/logger'
+require 'middleman-core/preview_server/server_information'
+require 'middleman-core/preview_server/server_url'
 
 # rubocop:disable GlobalVars
 module Middleman
-  module PreviewServer
+  class PreviewServer
     class << self
-      attr_reader :app, :host, :port, :ssl_certificate, :ssl_private_key
+      attr_reader :app, :ssl_certificate, :ssl_private_key, :environment, :server_information
       delegate :logger, to: :app
 
       def https?
@@ -19,11 +20,31 @@ module Middleman
       # Start an instance of Middleman::Application
       # @return [void]
       def start(opts={})
+        # Do not buffer output, otherwise testing of output does not work
+        $stdout.sync = true
+        $stderr.sync = true
+
         @options = opts
+        @server_information = ServerInformation.new
+
+        # New app evaluates the middleman configuration. Since this can be
+        # invalid as well, we need to evaluate the configuration BEFORE
+        # checking for validity
+        the_app = new_app
+
+        # And now comes the check
+        unless server_information.valid?
+          logger.fatal %(== Running Middleman failed: #{server_information.reason}. Please fix that and try again.)
+          exit 1
+        end
+
+        mount_instance(the_app)
 
-        mount_instance(new_app)
-        logger.info "== The Middleman is standing watch at #{uri} (#{uri(public_ip)})"
-        logger.info "== Inspect your site configuration at #{uri + '__middleman'}"
+        logger.debug %(== Server information is provided by #{server_information.handler})
+        logger.debug %(== The Middleman is running in "#{environment}" environment)
+        logger.debug format('== The Middleman preview server is bind to %s', ServerUrl.new(hosts: server_information.listeners, port: server_information.port, https: https?).to_bind_addresses.join(', '))
+        logger.info format('== View your site at %s', ServerUrl.new(hosts: server_information.site_addresses, port: server_information.port, https: https?).to_urls.join(', '))
+        logger.info format('== Inspect your site configuration at %s', ServerUrl.new(hosts: server_information.site_addresses, port: server_information.port, https: https?).to_config_urls.join(', '))
 
         @initialized ||= false
         return if @initialized
@@ -79,6 +100,10 @@ module Middleman
         end
 
         unmount_instance
+
+        @webrick.shutdown
+        @webrick = nil
+
         mount_instance(app)
 
         logger.info '== The Middleman has reloaded'
@@ -110,15 +135,26 @@ module Middleman
             opts[:instrumenting] || false
           )
 
-          config[:environment] = opts[:environment].to_sym if opts[:environment]
-          config[:port] = opts[:port] if opts[:port]
-          config[:https] = opts[:https] unless opts[:https].nil?
+          config[:environment]     = opts[:environment].to_sym if opts[:environment]
+          config[:port]            = opts[:port] if opts[:port]
+          config[:bind_address]    = opts[:bind_address]
+          config[:server_name]     = opts[:server_name]
+          config[:https]           = opts[:https] unless opts[:https].nil?
           config[:ssl_certificate] = opts[:ssl_certificate] if opts[:ssl_certificate]
           config[:ssl_private_key] = opts[:ssl_private_key] if opts[:ssl_private_key]
         end
 
-        @port = @app.config[:port]
-        @https = @app.config[:https]
+        # store configured port to make a check later on possible
+        configured_port = @app.config[:port]
+
+        # Use configuration values to set `bind_address` etc. in
+        # `server_information`
+        server_information.use @app.config
+
+        logger.warn format('== The Middleman uses a different port "%s" then the configured one "%s" because some other server is listening on that port.', server_information.port, configured_port) unless @app.config[:port] == configured_port
+
+        @https        = @app.config[:https]
+        @environment  = @app.config[:environment]
 
         @ssl_certificate = @app.config[:ssl_certificate]
         @ssl_private_key = @app.config[:ssl_private_key]
@@ -135,7 +171,7 @@ module Middleman
         options = { force_polling: @options[:force_polling] }
         options[:latency] = @options[:latency] if @options[:latency]
 
-        @listener = Listen.to(Dir.pwd, options) do |modified, added, removed|
+        @listener = Listen.to(::Middleman::Util.current_directory, options) do |modified, added, removed|
           added_and_modified = (modified + added)
 
           # See if the changed file is config.rb or lib/*.rb
@@ -143,14 +179,16 @@ module Middleman
             $mm_reload = true
             @webrick.stop
           else
+            wd = Pathname(::Middleman::Util.current_directory)
+
             added_and_modified.each do |path|
-              relative_path = Pathname(path).relative_path_from(Pathname(Dir.pwd)).to_s
+              relative_path = Pathname(path).relative_path_from(wd).to_s
               next if app.files.ignored?(relative_path)
               app.files.did_change(relative_path)
             end
 
             removed.each do |path|
-              relative_path = Pathname(path).relative_path_from(Pathname(Dir.pwd)).to_s
+              relative_path = Pathname(path).relative_path_from(wd).to_s
               next if app.files.ignored?(relative_path)
               app.files.did_delete(relative_path)
             end
@@ -179,8 +217,10 @@ module Middleman
       # @return [void]
       def setup_webrick(is_logging)
         http_opts = {
-          Port: port,
+          Port: server_information.port,
           AccessLog: [],
+          ServerName: server_information.server_name,
+          BindAddress: server_information.bind_address.to_s,
           DoNotReverseLookup: true
         }
 
@@ -188,15 +228,14 @@ module Middleman
           http_opts[:SSLEnable] = true
 
           if ssl_certificate || ssl_private_key
-            raise "You must provide both :ssl_certificate and :ssl_private_key" unless ssl_private_key && ssl_certificate
+            raise 'You must provide both :ssl_certificate and :ssl_private_key' unless ssl_private_key && ssl_certificate
             http_opts[:SSLCertificate] = OpenSSL::X509::Certificate.new File.read ssl_certificate
             http_opts[:SSLPrivateKey] = OpenSSL::PKey::RSA.new File.read ssl_private_key
           else
             # use a generated self-signed cert
-            http_opts[:SSLCertName] = [
-                                       %w(CN localhost),
-                                       %w(CN #{Socket.gethostname})
-                                      ].uniq
+            cert, key = create_self_signed_cert(1024, [['CN', server_information.server_name]], server_information.site_addresses, 'Middleman Preview Server')
+            http_opts[:SSLCertificate] = cert
+            http_opts[:SSLPrivateKey] = key
           end
         end
 
@@ -209,11 +248,44 @@ module Middleman
         begin
           ::WEBrick::HTTPServer.new(http_opts)
         rescue Errno::EADDRINUSE
-          logger.error "== Port #{port} is unavailable. Either close the instance of Middleman already running on #{port} or start this Middleman on a new port with: --port=#{port.to_i + 1}"
-          exit(1)
+          logger.error %(== Port "#{http_opts[:Port]}" is in use. This should not have happened. Please start "middleman server" again.)
         end
       end
 
+      # Copy of https://github.com/nahi/ruby/blob/webrick_trunk/lib/webrick/ssl.rb#L39
+      # that uses a different serial number each time the cert is generated in order to
+      # avoid errors in Firefox. Also doesn't print out stuff to $stderr unnecessarily.
+      def create_self_signed_cert(bits, cn, aliases, comment)
+        rsa = OpenSSL::PKey::RSA.new(bits)
+        cert = OpenSSL::X509::Certificate.new
+        cert.version = 2
+        cert.serial = Time.now.to_i % (1 << 20)
+        name = OpenSSL::X509::Name.new(cn)
+        cert.subject = name
+        cert.issuer = name
+        cert.not_before = Time.now
+        cert.not_after = Time.now + (365 * 24 * 60 * 60)
+        cert.public_key = rsa.public_key
+
+        ef = OpenSSL::X509::ExtensionFactory.new(nil, cert)
+        ef.issuer_certificate = cert
+        cert.extensions = [
+          ef.create_extension('basicConstraints', 'CA:FALSE'),
+          ef.create_extension('keyUsage', 'keyEncipherment'),
+          ef.create_extension('subjectKeyIdentifier', 'hash'),
+          ef.create_extension('extendedKeyUsage', 'serverAuth'),
+          ef.create_extension('nsComment', comment)
+        ]
+        aki = ef.create_extension('authorityKeyIdentifier',
+                                  'keyid:always,issuer:always')
+        cert.add_extension(aki)
+        cert.add_extension ef.create_extension('subjectAltName', aliases.map { |d| "DNS: #{d}" }.join(','))
+
+        cert.sign(rsa, OpenSSL::Digest::SHA1.new)
+
+        [cert, rsa]
+      end
+
       # Attach a new Middleman::Application instance
       # @param [Middleman::Application] app
       # @return [void]
@@ -261,21 +333,6 @@ module Middleman
           end
         end
       end
-
-      # Returns the URI the preview server will run on
-      # @return [URI]
-      def uri(host = Socket.gethostname)
-        scheme = https? ? 'https' : 'http'
-        URI("#{scheme}://#{host}:#{@port}/")
-      end
-
-      # An IPv4 address on this machine which should be externally addressable.
-      # @return [String]
-      def public_ip
-        ip = Socket.ip_address_list.find { |ai| ai.ipv4? && !ai.ipv4_loopback? }
-        ip ? ip.ip_address : '127.0.0.1'
-      end
-
     end
 
     class FilteredWebrickLog < ::WEBrick::Log

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

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