mailcatcher-ng 1.0.0

data/lib/mail_catcher/web/application.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "net/http"
+require "uri"
+
+require "faye/websocket"
+require "sinatra"
+
+require "mail_catcher/bus"
+require "mail_catcher/mail"
+
+Faye::WebSocket.load_adapter("thin")
+
+# Faye's adapter isn't smart enough to close websockets when thin is stopped,
+# so we teach it to do so.
+class Thin::Backends::Base
+  alias :thin_stop :stop
+
+  def stop
+    thin_stop
+    @connections.each_value do |connection|
+      if connection.socket_stream
+        connection.socket_stream.close_connection_after_writing
+      end
+    end
+  end
+end
+
+class Sinatra::Request
+  include Faye::WebSocket::Adapter
+end
+
+module MailCatcher
+  module Web
+    class Application < Sinatra::Base
+      set :environment, MailCatcher.env
+      set :prefix, MailCatcher.options[:http_path]
+      set :asset_prefix, File.join(prefix, "assets")
+      set :root, File.expand_path("#{__FILE__}/../../../..")
+
+      if development?
+        require "sprockets-helpers"
+
+        configure do
+          require "mail_catcher/web/assets"
+          Sprockets::Helpers.configure do |config|
+            config.environment = Assets
+            config.prefix      = settings.asset_prefix
+            config.digest      = false
+            config.public_path = public_folder
+            config.debug       = true
+          end
+        end
+
+        helpers do
+          include Sprockets::Helpers
+        end
+      else
+        helpers do
+          def asset_path(filename)
+            File.join(settings.asset_prefix, filename)
+          end
+        end
+      end
+
+      get "/" do
+        @version = MailCatcher::VERSION
+        erb :index
+      end
+
+      get "/websocket-test" do
+        erb :websocket_test
+      end
+
+      get "/server-info" do
+        @version = MailCatcher::VERSION
+        @smtp_ip = MailCatcher.options[:smtp_ip]
+        @smtp_port = MailCatcher.options[:smtp_port]
+        @http_ip = MailCatcher.options[:http_ip]
+        @http_port = MailCatcher.options[:http_port]
+        @http_path = MailCatcher.options[:http_path]
+
+        require "socket"
+        if @http_ip == "127.0.0.1"
+          @hostname = "localhost"
+          @fqdn = "localhost"
+        else
+          begin
+            hostname = Socket.gethostname
+            fqdn = Socket.getfqdn(Socket.gethostname)
+          rescue
+            hostname = "unknown"
+            fqdn = "unknown"
+          end
+          @hostname = hostname
+          @fqdn = fqdn
+        end
+
+        erb :server_info
+      end
+
+      delete "/" do
+        if MailCatcher.quittable?
+          MailCatcher.quit!
+          status 204
+        else
+          status 403
+        end
+      end
+
+      get "/messages" do
+        if request.websocket?
+          bus_subscription = nil
+
+          ws = Faye::WebSocket.new(request.env)
+
+          ws.on(:open) do |_|
+            $stderr.puts "[WebSocket] Connection opened"
+            bus_subscription = MailCatcher::Bus.subscribe do |message|
+              begin
+                $stderr.puts "[WebSocket] Sending message: #{message.inspect}"
+                ws.send(JSON.generate(message))
+              rescue => exception
+                $stderr.puts "[WebSocket] Error sending message: #{exception.message}"
+                MailCatcher.log_exception("Error sending message through websocket", message, exception)
+              end
+            end
+          end
+
+          ws.on(:close) do |_|
+            $stderr.puts "[WebSocket] Connection closed"
+            MailCatcher::Bus.unsubscribe(bus_subscription) if bus_subscription
+          end
+
+          ws.on(:error) do |event|
+            $stderr.puts "[WebSocket] WebSocket error: #{event}"
+          end
+
+          ws.rack_response
+        else
+          content_type :json
+          JSON.generate(Mail.messages)
+        end
+      end
+
+      delete "/messages" do
+        Mail.delete!
+        status 204
+      end
+
+      get "/messages/:id.json" do
+        id = params[:id].to_i
+        if message = Mail.message(id)
+          content_type :json
+          JSON.generate(message.merge({
+            "formats" => [
+              "source",
+              ("html" if Mail.message_has_html? id),
+              ("plain" if Mail.message_has_plain? id)
+            ].compact,
+            "attachments" => Mail.message_attachments(id),
+            "bimi_location" => Mail.message_bimi_location(id),
+            "preview_text" => Mail.message_preview_text(id),
+            "authentication_results" => Mail.message_authentication_results(id),
+            "encryption_data" => Mail.message_encryption_data(id),
+            "from_header" => Mail.message_from(id),
+            "to_header" => Mail.message_to(id),
+          }))
+        else
+          not_found
+        end
+      end
+
+      get "/messages/:id.html" do
+        id = params[:id].to_i
+        if part = Mail.message_part_html(id)
+          content_type :html, :charset => (part["charset"] || "utf8")
+
+          body = part["body"]
+
+          # Rewrite body to link to embedded attachments served by cid
+          body = body.gsub /cid:([^'"> ]+)/, "#{id}/parts/\\1"
+
+          body
+        else
+          not_found
+        end
+      end
+
+      get "/messages/:id.plain" do
+        id = params[:id].to_i
+        if part = Mail.message_part_plain(id)
+          content_type part["type"], :charset => (part["charset"] || "utf8")
+          part["body"]
+        else
+          not_found
+        end
+      end
+
+      get "/messages/:id.source" do
+        id = params[:id].to_i
+        if message_source = Mail.message_source(id)
+          content_type "text/plain"
+          message_source
+        else
+          not_found
+        end
+      end
+
+      get "/messages/:id.eml" do
+        id = params[:id].to_i
+        if message_source = Mail.message_source(id)
+          content_type "message/rfc822"
+          message_source
+        else
+          not_found
+        end
+      end
+
+      get "/messages/:id/parts/:cid" do
+        id = params[:id].to_i
+        if part = Mail.message_part_cid(id, params[:cid])
+          content_type part["type"], :charset => (part["charset"] || "utf8")
+          attachment part["filename"] if part["is_attachment"] == 1
+          body part["body"].to_s
+        else
+          not_found
+        end
+      end
+
+      delete "/messages/:id" do
+        id = params[:id].to_i
+        if Mail.message(id)
+          Mail.delete_message!(id)
+          status 204
+        else
+          not_found
+        end
+      end
+
+      not_found do
+        erb :"404"
+      end
+    end
+  end
+end

data/lib/mail_catcher/web.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "rack/builder"
+
+require "mail_catcher/web/application"
+
+module MailCatcher
+  module Web extend self
+    def app
+      @@app ||= Rack::Builder.new do
+        map(MailCatcher.options[:http_path]) do
+          if MailCatcher.development?
+            require "mail_catcher/web/assets"
+            map("/assets") { run Assets }
+          end
+
+          run Application
+        end
+
+        # This should only affect when http_path is anything but "/" above
+        run lambda { |env| [302, {"Location" => MailCatcher.options[:http_path]}, []] }
+      end
+    end
+
+    def call(env)
+      app.call(env)
+    end
+  end
+end

data/lib/mail_catcher.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'open3'
+require 'optparse'
+require 'rbconfig'
+
+require 'eventmachine'
+require 'thin'
+
+module EventMachine
+  # Monkey patch fix for 10deb4
+  # See https://github.com/eventmachine/eventmachine/issues/569
+  def self.reactor_running?
+    @reactor_running || false
+  end
+end
+
+require 'mail_catcher/version'
+
+module MailCatcher
+  extend self
+  autoload :Bus, 'mail_catcher/bus'
+  autoload :Mail, 'mail_catcher/mail'
+  autoload :Smtp, 'mail_catcher/smtp'
+  autoload :Web, 'mail_catcher/web'
+
+  @logger = Logger.new($stdout)
+  @logger.level = Logger::INFO
+
+  def env
+    ENV.fetch('MAILCATCHER_ENV', 'production')
+  end
+
+  def development?
+    env == 'development'
+  end
+
+  def which?(command)
+    ENV['PATH'].split(File::PATH_SEPARATOR).any? do |directory|
+      File.executable?(File.join(directory, command.to_s))
+    end
+  end
+
+  def windows?
+    RbConfig::CONFIG['host_os'].match?(/mswin|mingw/)
+  end
+
+  def browsable?
+    windows? or which? 'open'
+  end
+
+  def browse(url)
+    if windows?
+      system 'start', '/b', url
+    elsif which? 'open'
+      system 'open', url
+    end
+  end
+
+  def log_exception(message, context, exception)
+    gems_paths = (Gem.path | [Gem.default_dir]).map { |path| Regexp.escape(path) }
+    gems_regexp = %r{(?:#{gems_paths.join('|')})/gems/([^/]+)-([\w.]+)/(.*)}
+    gems_replace = '\1 (\2) \3'
+
+    @logger.error("#{message}: #{context.inspect}")
+    @logger.error("Exception: #{exception}")
+
+    backtrace = exception.backtrace&.map { |line| line.sub(gems_regexp, gems_replace) }
+    backtrace&.each { |line| @logger.error("  #{line}") }
+
+    @logger.error('Please submit this as an issue at https://github.com/spaquet/mailcatcher')
+  end
+
+  @defaults = {
+    smtp_ip: '127.0.0.1',
+    smtp_port: '1025',
+    http_ip: '127.0.0.1',
+    http_port: '1080',
+    http_path: '/',
+    messages_limit: nil,
+    verbose: false,
+    daemon: !windows?,
+    browse: false,
+    quit: true
+  }
+
+  def options
+    @options
+  end
+
+  def quittable?
+    options[:quit]
+  end
+
+  def parse!(arguments = ARGV, defaults = @defaults)
+    @defaults.dup.tap do |options|
+      OptionParser.new do |parser|
+        parser.banner = 'Usage: mailcatcher [options]'
+        parser.version = VERSION
+        parser.separator ''
+        parser.separator "MailCatcher v#{VERSION}"
+        parser.separator ''
+
+        parser.on('--ip IP', 'Set the ip address of both servers') do |ip|
+          options[:smtp_ip] = options[:http_ip] = ip
+        end
+
+        parser.on('--smtp-ip IP', 'Set the ip address of the smtp server') do |ip|
+          options[:smtp_ip] = ip
+        end
+
+        parser.on('--smtp-port PORT', Integer, 'Set the port of the smtp server') do |port|
+          options[:smtp_port] = port
+        end
+
+        parser.on('--http-ip IP', 'Set the ip address of the http server') do |ip|
+          options[:http_ip] = ip
+        end
+
+        parser.on('--http-port PORT', Integer, 'Set the port address of the http server') do |port|
+          options[:http_port] = port
+        end
+
+        parser.on('--messages-limit COUNT', Integer,
+                  'Only keep up to COUNT most recent messages') do |count|
+          options[:messages_limit] = count
+        end
+
+        parser.on('--http-path PATH', String, 'Add a prefix to all HTTP paths') do |path|
+          clean_path = Rack::Utils.clean_path_info("/#{path}")
+
+          options[:http_path] = clean_path
+        end
+
+        parser.on('--no-quit', "Don't allow quitting the process") do
+          options[:quit] = false
+        end
+
+        unless windows?
+          parser.on('-f', '--foreground', 'Run in the foreground') do
+            options[:daemon] = false
+          end
+        end
+
+        if browsable?
+          parser.on('-b', '--browse', 'Open web browser') do
+            options[:browse] = true
+          end
+        end
+
+        parser.on('-v', '--verbose', 'Be more verbose') do
+          options[:verbose] = true
+        end
+
+        parser.on_tail('-h', '--help', 'Display this help information') do
+          puts parser
+          exit
+        end
+
+        parser.on_tail('--version', 'Display the current version') do
+          puts "MailCatcher v#{VERSION}"
+          exit
+        end
+      end.parse!
+    end
+  end
+
+  def run!(options = nil)
+    # If we are passed options, fill in the blanks
+    options &&= @defaults.merge options
+    # Otherwise, parse them from ARGV
+    options ||= parse!
+
+    # Stash them away for later
+    @options = options
+
+    # If we're running in the foreground sync the output.
+    $stdout.sync = $stderr.sync = true unless options[:daemon]
+
+    @logger.info("Starting MailCatcher v#{VERSION}")
+
+    Thin::Logging.debug = development?
+    Thin::Logging.silent = !development?
+    @logger.level = development? ? Logger::DEBUG : Logger::INFO
+
+    # One EventMachine loop...
+    EventMachine.run do
+      # Set up an SMTP server to run within EventMachine
+      rescue_port options[:smtp_port] do
+        EventMachine.start_server options[:smtp_ip], options[:smtp_port], Smtp
+        @logger.info("==> #{smtp_url}")
+      end
+
+      # Let Thin set itself up inside our EventMachine loop
+      # Faye connections are hijacked but continue to be supervised by thin
+      rescue_port options[:http_port] do
+        Thin::Server.start(options[:http_ip], options[:http_port], Web, signals: false)
+        @logger.info("==> #{http_url}")
+      end
+
+      # Make sure we quit nicely when asked
+      # We need to handle outside the trap context, hence the timer
+      trap('INT') { EM.add_timer(0) { quit! } }
+      trap('TERM') { EM.add_timer(0) { quit! } }
+      trap('QUIT') { EM.add_timer(0) { quit! } } unless windows?
+
+      # Open the web browser before detaching console
+      if options[:browse]
+        EventMachine.next_tick do
+          browse http_url
+        end
+      end
+
+      # Daemonize, if we should, but only after the servers have started.
+      if options[:daemon]
+        EventMachine.next_tick do
+          if quittable?
+            @logger.info('MailCatcher runs as a daemon by default. Go to the web interface to quit.')
+          else
+            @logger.info('MailCatcher is now running as a daemon that cannot be quit.')
+          end
+          Process.daemon
+        end
+      end
+    end
+  end
+
+  def quit!
+    MailCatcher::Bus.push(type: 'quit')
+
+    EventMachine.next_tick { EventMachine.stop_event_loop }
+  end
+
+  protected
+
+  def smtp_url
+    "smtp://#{@options[:smtp_ip]}:#{@options[:smtp_port]}"
+  end
+
+  def http_url
+    "http://#{@options[:http_ip]}:#{@options[:http_port]}#{@options[:http_path]}".chomp('/')
+  end
+
+  def rescue_port(port)
+    yield
+
+  # XXX: EventMachine only spits out RuntimeError with a string description
+  rescue RuntimeError
+    raise unless $!.to_s =~ /\bno acceptor\b/
+
+    @logger.error("Something's using port #{port}. Are you already running MailCatcher?")
+    @logger.error("==> #{smtp_url}")
+    @logger.error("==> #{http_url}")
+    exit(-1)
+  end
+end

data/lib/mailcatcher.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'mail_catcher'
+
+Mailcatcher = MailCatcher