celluloid-smtp 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c5a69f2ed269acb76e89ee43e1e60412dc5a3a03
+  data.tar.gz: ce63f363549dc3772f9e4196801a7b4ea41d14dc
+SHA512:
+  metadata.gz: 3ee9844f6d97980fdda68a8cd9d5f7f41c5ffc410a95ffdb44a086fb3ea206ca51e9e0adbc67f8ad9a68b5504c81c6a1f5fb18369400b912f67802517cc35b81
+  data.tar.gz: 7d222884724f3df4ebfaef75ab5c1409307606b909b23f6e21aa7c9c37fb8cd8f30b1eca8ddea2dc4587b690f3dcdce35ef4848451304061057a8133a1b5bfa4

data/.gitignore

@@ -0,0 +1,4 @@
+Gemfile.lock
+.DS_Store
+*.log
+pkg/*

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "culture"]
+	path = culture
+	url = http://github.com/celluloid/culture.git

data/CHANGES.md

@@ -0,0 +1,2 @@
+0.0.0.9
+- Decided to remove "block form" compatibility for now, in favor of overriding various events.

data/Gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem 'celluloid', github: 'celluloid/celluloid', branch: '0.17.0-prerelease', submodules: true
+gem 'celluloid-io', github: 'celluloid/celluloid-io', branch: '0.17.0-dependent', submodules: true
+
+#de For debugging. Watching for thread leaks.
+gem 'cellumon', github: 'digitalextremist/cellumon', branch: 'master'

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 //de ( digitalextremist // )
+
+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,6 @@
+# cellulloid-smtp
+
+Evented, actor-based SMTP server built on [Celluloid::IO](http://github.com/celluloid/celluloid-io).
+
+Inspired by [midi-smtp-server](https://github.com/4commerce-technologies-AG/midi-smtp-server),
+but mostly based on [Reel](http://github.com/celluloid/reel).

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/celluloid-smtp.gemspec

@@ -0,0 +1,21 @@
+require File.expand_path("../culture/sync", __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name        = 'celluloid-smtp'
+  gem.version     = Celluloid::SMTP::VERSION
+
+  gem.summary     = "Celluloid based SMTP server."
+  gem.description = "A small, fast, evented, actor-based, highly customizable Ruby SMTP server."
+
+  gem.authors     = ["digitalextremist //"]
+  gem.email       = 'code@extremist.digital'
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.require_paths = ["lib"]
+
+  gem.homepage    = 'https://github.com/abstractive/celluloid-smtp'
+  gem.license     = 'MIT'
+
+  gem.add_development_dependency "mail"
+end

data/examples/basic_server.rb

@@ -0,0 +1,17 @@
+$LOAD_PATH.push(File.expand_path("../../lib", __FILE__))
+
+require 'bundler/setup'
+require 'celluloid/smtp'
+
+at_exit {
+  Celluloid::Internals::Logger.info "Shutting down SMTP server."
+  Celluloid[:smtpd].async.shutdown
+  sleep 0.126 * 2
+  Celluloid.shutdown
+}
+
+begin
+  Celluloid::SMTP::Server.run
+rescue Interrupt
+  exit
+end

data/examples/test_load.rb

@@ -0,0 +1,78 @@
+$LOAD_PATH.push(File.expand_path("../../lib", __FILE__))
+
+require 'bundler/setup'
+require 'celluloid/current'
+require 'mail'
+
+TESTS = 1000
+THREADS = 4
+
+HOST = ARGV[0] || "localhost"
+PORT = (ARGV[1] || 2525).to_i
+TO = ARGV[2] || "smtp@celluloid.io"
+FROM = ARGV[3] || TO
+
+Mail.defaults do
+  delivery_method :smtp, address: HOST, port: PORT
+end
+
+fail "No TO address specified." unless TO
+
+puts "Simulating sending #{TESTS}x#{THREADS} messages through #{HOST}@#{PORT}."
+
+class Sender
+  include Celluloid
+  def tests(count)
+    times = count.times.map { future.test }
+    values = times.map(&:value)
+    failures = values.select { |v| v == :fail }.count
+    values.select! { |v| v != :fail }
+    average = values.inject{ |sum, t| sum + t }.to_f / values.size
+    return [0, failures] if failures == count
+    [average,failures]
+  end
+  def test
+    start = Time.now
+    mail = Mail.new do
+      from      FROM
+      to        TO
+      subject   'Test email.'
+      body      "Test message.... #{Time.now}"
+    end
+
+    begin
+      mail.deliver
+      print "."
+      return Time.now.to_f - start.to_f
+    rescue => ex
+      print "!"
+      :fail
+    end
+  end
+end
+
+senders = THREADS.times.map { Sender.new }
+
+start = Time.now
+tests = senders.map {|sender| sender.future.tests(TESTS) }
+
+values = tests.map(&:value)
+total = Time.now-start
+total_fail = false
+
+puts "\n\n\n* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *"
+failures = values.map { |v| v[1] }.inject{ |sum,f| sum + f }
+average = values.map { |v| v[0] }.inject{ |sum, t| sum + t }.to_f / values.size
+overall_average = total/(TESTS*THREADS)
+if total_fail
+  puts "\n    All #{THREADS*TESTS} messages failed."
+  total_fail = true
+end
+puts "\n    Failures: #{failures}"
+puts "\n    Average time for #{TESTS}x#{THREADS} messages:"
+puts "      ~#{"%0.4f" % average} seconds per message, actual estimate." unless total_fail
+puts "      ~#{"%0.4f" % (overall_average)} of overall runtime, per message."
+puts "\n    Total time running test: #{"%0.4f" % total} seconds:"
+puts "      ~#{"%0.4f" % (1/average)} messages per second, actual estimate." unless total_fail
+puts "      ~#{"%0.4f" % (1/overall_average)} messages per second, overall."
+puts "\n* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n\n\n"

data/examples/test_messages.rb

@@ -0,0 +1,56 @@
+$LOAD_PATH.push(File.expand_path("../../lib", __FILE__))
+
+require 'bundler/setup'
+require 'mail'
+
+INTERVAL = 2.22
+
+Mail.defaults do
+  delivery_method :smtp, address: "localhost", port: 2525
+end
+
+TO = "smtp@celluloid.io"
+FROM = TO
+
+fail "No TO address specified." unless TO
+
+puts "Simulating sending a message every #{INTERVAL} seconds."
+
+futures = []
+@mutex = Mutex.new
+begin
+  Thread.new {
+    @mutex.synchronize {
+      loop {
+        futures = Thread.new {
+          start = Time.now
+          mail = Mail.new do
+            from      FROM
+            to        TO
+            subject   'Test email.'
+            body      "Test message.... #{start}"
+          end
+
+          begin
+            mail.deliver
+            print "|"
+          rescue Errno::ECONNREFUSED
+            print "X"
+          rescue EOFError
+            print "?"
+          rescue => ex
+            print "!"
+            STDERR.puts "Error communicating with server: #{ex} (#{ex.class})"
+          end
+        }  
+        sleep INTERVAL
+      }
+    }
+  }
+
+  loop {
+    future = @mutex.synchronize { futures.shift }.value rescue nil
+  }
+rescue Interrupt
+  puts "Done testing."
+end

data/lib/celluloid/smtp.rb

@@ -0,0 +1,26 @@
+require 'celluloid/current'
+require 'celluloid/io'
+
+module Celluloid
+  module SMTP
+    require 'celluloid/smtp/constants'
+    require 'celluloid/smtp/logging'
+    require 'celluloid/smtp/version'
+    require 'celluloid/smtp/extensions'
+    class Server
+      include SMTP::Extensions
+      require 'celluloid/smtp/server'
+      require 'celluloid/smtp/server/protector'
+      require 'celluloid/smtp/server/handler'
+      require 'celluloid/smtp/server/transporter'
+    end
+    class Connection
+      include SMTP::Extensions
+      require 'celluloid/smtp/connection/errors'
+      require 'celluloid/smtp/connection/events'
+      require 'celluloid/smtp/connection/parser'
+      require 'celluloid/smtp/connection/automata'
+      require 'celluloid/smtp/connection'
+    end
+  end
+end

data/lib/celluloid/smtp/connection.rb

@@ -0,0 +1,54 @@
+class Celluloid::SMTP::Connection
+
+  attr_reader :socket, :automata
+
+  extend Forwardable
+  def_delegators :@socket, :close, :peeraddr, :print, :closed?
+  def_delegators :@automata, :transition
+
+  def initialize(socket, configuration)
+    @automata = Automata.new(self)
+    @configuration = configuration.dup
+    @socket = socket
+    @timestamps = {}
+    @context = nil
+    @behavior = configuration.fetch(:behavior, DEFAULT_BEHAVIOR)
+    transition :connection
+  end
+
+  def start!
+    @timestamps[:start] = Time.now
+  end
+
+  def finish!
+    @timestamps[:finish] = Time.now
+  end
+
+  def length
+    raise "Connection incomplete." unless @timestamps[:start] && @timestamps[:finish]
+    @timestamps[:finish].to_f - @timestamps[:start].to_f
+  end
+
+  def relaying?
+    @behavior == :relay
+  end
+
+  def delivering?
+    @behavior == :deliver
+  end
+
+  def print!(string)
+    print "#{string}\r\n"
+  end
+
+  def remote_ip
+    peeraddr(false)[3]
+  end
+  alias remote_addr remote_ip
+
+  def remote_host
+    # NOTE: This is currently a blocking operation.
+    peeraddr(true)[2]
+  end
+
+end

data/lib/celluloid/smtp/connection/automata.rb

@@ -0,0 +1,70 @@
+class Celluloid::SMTP::Connection::Automata
+  include Celluloid::FSM
+  include Celluloid::SMTP::Extensions
+  def_delegators :@connection,
+                 :delivering?,
+                 :relaying?,
+                 :closed?,
+                 :start!,
+                 :finish!,
+                 :print,
+                 :length,
+                 :event!,
+                 :handle!
+
+  def initialize(connection)
+    @connection = connection
+  end
+
+  default_state :initialize
+
+  state :connection, :to => [:handling, :closed] do
+    start!
+    event!(:on_connection)
+    transition :handling
+  end
+
+  state :handling, :to => [:handled, :disconnecting, :closed] do
+    debug "Parsing message." if DEBUG_AUTOMATA
+    handle!
+  end
+
+  state :handled, :to => [:relaying, :delivering, :disconnecting, :closed] do
+    debug "Finished handling." if DEBUG_AUTOMATA
+    if relaying?
+      transition :relaying
+    elsif delivering?
+      transition :delivering
+    else
+      transition :disconnecting
+    end
+  end
+
+  state :relaying, to: [:relayed, :closed] do
+    debug "Relaying message." if DEBUG_AUTOMATA
+  end
+
+  state :relayed, to: [:disconnecting, :closed] do
+    debug "Message relayed." if DEBUG_AUTOMATA
+  end
+
+  state :delivering, to: [:delivered, :closed] do
+    debug "Delivering message."  if DEBUG_AUTOMATA
+
+  end
+
+  state :delivered, to: [:disconnecting, :closed] do
+    debug "Message delivered."  if DEBUG_AUTOMATA
+  end
+
+  state :disconnecting, to: [:closed] do
+    event!(:on_disconnect)
+    transition :closed
+  end
+
+  state :closed, :to => [] do
+    close unless closed? rescue nil
+    finish!
+    debug "TIMER: #{"%0.4f" % length} on connection." if DEBUG_TIMING
+  end
+end

data/lib/celluloid/smtp/connection/errors.rb

@@ -0,0 +1,97 @@
+module Celluloid::SMTP
+  class Exception < ::Exception
+    attr_reader :code, :text
+    def initialize(msg=nil, code, text)
+      @code = code
+      @text = text
+      super msg
+    end
+    def result
+      "#{@code} #{@text}"
+    end    
+  end
+
+  class Error421 < Exception
+    def initialize(msg="")
+      super msg, 421, "Service not available, closing transmission channel"
+    end
+  end
+
+  class Error450 < Exception
+    def initialize(msg="")
+      super msg, 450, "Requested mail action not taken: mailbox unavailable"
+    end
+  end
+
+  class Error451 < Exception
+    def initialize(msg="")
+      super msg, 451, "Requested action aborted: local error in processing"
+    end
+  end
+
+  class Error452 < Exception
+    def initialize(msg="")
+      super msg, 452, "Requested action not taken: insufficient system storage"
+    end
+  end
+
+  class Error500 < Exception
+    def initialize(msg="")
+      super msg, 500, "Syntax error, command unrecognised or error in parameters or arguments"
+    end
+  end
+
+  class Error501 < Exception
+    def initialize(msg="")
+      super msg, 501, "Syntax error in parameters or arguments"
+    end
+  end
+
+  class Error502 < Exception
+    def initialize(msg="")
+      super msg, 502, "Command not implemented"
+    end
+  end
+
+  class Error503 < Exception
+    def initialize(msg="")
+      super msg, 503, "Bad sequence of commands"
+    end
+  end
+
+  class Error504 < Exception
+    def initialize(msg="")
+      super msg, 504, "Command parameter not implemented"
+    end
+  end
+
+  class Error521 < Exception
+    def initialize(msg="")
+      super msg, 521, "Service does not accept mail"
+    end
+  end
+
+  class Error550 < Exception
+    def initialize(msg="")
+      super msg, 550, "Requested action not taken: mailbox unavailable"
+    end
+  end
+
+  class Error552 < Exception
+    def initialize(msg="")
+      super msg, 552, "Requested mail action aborted: exceeded storage allocation"
+    end
+  end
+
+  class Error553 < Exception
+    def initialize(msg="")
+      super msg, 553, "Requested action not taken: mailbox name not allowed"
+    end
+  end
+
+  class Error554 < Exception
+    def initialize(msg="")
+      super msg, 554, "Transaction failed"
+    end
+  end
+end

data/lib/celluloid/smtp/connection/events.rb

@@ -0,0 +1,41 @@
+class Celluloid::SMTP::Connection
+
+  def event!(method,*args)
+    start = Time.now
+    debug("Executing event: #{method}") if DEBUG_EVENTS
+    result = send(method,*args)
+    debug("TIMER: #{"%0.4f" %(Time.now-start)} on event: #{method}") if DEBUG_TIMING
+    result
+  rescue => ex
+    exception(ex, "Failure in event processor: #{method}")
+    nil
+  end
+
+  def on_connection
+    debug("Client connected.") if DEBUG_EVENTS
+  end
+
+  def on_disconnect
+    debug("Disconnecting client.") if DEBUG_EVENTS
+  end
+
+  def on_helo(helo)
+    debug("HELO: #{helo}") if DEBUG_EVENTS
+    return helo
+  end
+
+  def on_mail_from(from)
+    debug("MAIL FROM: #{from}") if DEBUG_EVENTS
+    return from
+  end
+
+  def on_rcpt_to(to)
+    debug("RCPT TO: #{to}") if DEBUG_EVENTS
+    return to
+  end
+
+  def on_message(message)
+    debug("MESSAGE") if DEBUG_EVENTS
+    return message[:data]
+  end
+end

data/lib/celluloid/smtp/connection/parser.rb

@@ -0,0 +1,184 @@
+class Celluloid::SMTP::Connection
+
+  include Celluloid::SMTP
+
+  def handle!
+    context!(true)
+    if process!
+      transition :handled
+    else
+      transition :disconnecting
+    end
+  rescue => ex
+    exception(ex, "Error handling command session")
+    transition :closed
+  end
+
+  [:data, :quit, :helo, :mail, :rcpt, :rset].each { |command|
+    define_method(:"#{command}?") { @sequence == command }
+    define_method(:"#{command}!") { @sequence = command }
+  }
+
+  def context!(first=false)
+    @helo = nil if first
+    @sequence = first ? :helo : :rset
+    @context = {} if first || @context.nil?
+    @context[:envelope] = {from: "", to: []}
+    @context[:message] = {delivered: -1, bytesize: -1, data: ""}
+  end
+
+  def envelope;   @context[:envelope] ||= {}   end
+  def message;    @context[:message] ||= {}    end
+
+  def process!
+    print! "220 #{@configuration[:hostname]} says welcome!"
+    begin
+      loop {
+        output = begin
+          data = @socket.readline
+          debug(">> #{data.chomp}") unless data? if DEBUG
+          line! data
+        rescue Celluloid::SMTP::Exception => ex
+          exception(ex, "Processing error")
+        rescue => ex
+          exception(ex, "Unknown exception")
+          Error500.new.result
+        end
+        unless output.empty?
+          debug("<< #{output}") if DEBUG
+          print! output
+        end
+        break if quit? || closed?
+      }
+      print! "221 Service closing transmission channel" unless closed?
+      return true
+    rescue EOFError
+      debug("Lost connection due to client abort.")
+    rescue Exception => ex
+      exception(ex, "Error parsing command session")
+      print! Error421.new.result unless closed?
+    end
+    false
+  end
+
+  def line!(data)
+    unless data?
+      case data 
+      when (/^(HELO|EHLO)(\s+.*)?$/i) # HELO/EHLO    
+        # 250 Requested mail action okay, completed
+        # 421 <domain> Service not available, closing transmission channel
+        # 500 Syntax error, command unrecognised
+        # 501 Syntax error in parameters or arguments
+        # 504 Command parameter not implemented
+        # 521 <domain> does not accept mail [rfc1846]
+        raise Error503 unless helo?
+        data = data.gsub(/^(HELO|EHLO)\ /i, '').strip
+        if return_value = event!(:on_helo, data)
+          data = return_value
+        end
+        @helo = data
+        rset!
+        return "250 OK"
+      when (/^NOOP\s*$/i) # NOOP
+        # 250 Requested mail action okay, completed
+        # 421 <domain> Service not available, closing transmission channel
+        # 500 Syntax error, command unrecognised
+        return "250 OK"
+      when (/^RSET\s*$/i) # RSET
+        # 250 Requested mail action okay, completed
+        # 421 <domain> Service not available, closing transmission channel
+        # 500 Syntax error, command unrecognised
+        # 501 Syntax error in parameters or arguments
+        raise Error503 if helo?
+        # handle command
+        context!
+        return "250 OK"        
+      when (/^QUIT\s*$/i) # QUIT
+        # 221 <domain> Service closing transmission channel
+        # 500 Syntax error, command unrecognised
+        quit!
+        return ""
+      when (/^MAIL FROM\:/i) # MAIL
+        # 250 Requested mail action okay, completed
+        # 421 <domain> Service not available, closing transmission channel
+        # 451 Requested action aborted: local error in processing
+        # 452 Requested action not taken: insufficient system storage
+        # 500 Syntax error, command unrecognised
+        # 501 Syntax error in parameters or arguments
+        # 552 Requested mail action aborted: exceeded storage allocation
+        raise Error503 unless rset?
+        data = data.gsub(/^MAIL FROM\:/i, '').strip
+        if return_value = event!(:on_mail_from, data)
+          data = return_value
+        end
+        envelope[:from] = data
+        mail!
+        return "250 OK"        
+      when (/^RCPT TO\:/i) # RCPT
+        # 250 Requested mail action okay, completed
+        # 251 User not local; will forward to <forward-path>
+        # 421 <domain> Service not available, closing transmission channel
+        # 450 Requested mail action not taken: mailbox unavailable
+        # 451 Requested action aborted: local error in processing
+        # 452 Requested action not taken: insufficient system storage
+        # 500 Syntax error, command unrecognised
+        # 501 Syntax error in parameters or arguments
+        # 503 Bad sequence of commands
+        # 521 <domain> does not accept mail [rfc1846]
+        # 550 Requested action not taken: mailbox unavailable
+        # 551 User not local; please try <forward-path>
+        # 552 Requested mail action aborted: exceeded storage allocation
+        # 553 Requested action not taken: mailbox name not allowed
+        raise Error503 unless mail? || rset?
+        data = data.gsub(/^RCPT TO\:/i, '').strip
+        if return_value = event!(:on_rcpt_to, data)
+          data = return_value
+        end
+        envelope[:to] << data
+        rset!
+        return "250 OK"        
+      when (/^DATA\s*$/i) # DATA
+        # 354 Start mail input; end with <CRLF>.<CRLF>
+        # 250 Requested mail action okay, completed
+        # 421 <domain> Service not available, closing transmission channel received data
+        # 451 Requested action aborted: local error in processing
+        # 452 Requested action not taken: insufficient system storage
+        # 500 Syntax error, command unrecognised
+        # 501 Syntax error in parameters or arguments
+        # 503 Bad sequence of commands
+        # 552 Requested mail action aborted: exceeded storage allocation
+        # 554 Transaction failed
+        raise Error503 unless rset?
+        data!
+        return "354 Enter message, ending with \".\" on a data by itself"
+      else
+        raise Error500
+      end
+    else # Data mode.
+      if (data.chomp =~ /^\.$/) # Line with only a period; being told to exit data mode.
+        message[:data] += data
+        message[:data].gsub!(/\r\n\Z/, '').gsub!(/\.\Z/, '')    # remove ending line .
+        begin
+          if return_value = event!(:on_message, @context)
+            message[:data] = return_value
+          end
+          message[:delivered] = Time.now.utc                    # save delivered time
+          message[:bytesize] = message[:data].bytesize          # save bytesize of message data
+          return "250 Requested mail action okay, completed"
+
+        rescue Celluloid::SMTP::Exception
+          raise
+        rescue Exception => ex
+          raise Error451.new("#{ex}")
+        ensure
+          context!
+        end
+      else
+        message[:data] += data
+        return ""
+      end
+
+    end
+  end
+  
+end

data/lib/celluloid/smtp/constants.rb

@@ -0,0 +1,15 @@
+module Celluloid::SMTP::Constants
+  DEBUG = false
+  DEBUG_TIMING = true
+  DEBUG_AUTOMATA = false
+  DEBUG_EVENTS = false
+
+  HANDLERS = 0
+  LOGGER = Celluloid::Internals::Logger
+  DEFAULT_HOST = '127.0.0.1'
+  DEFAULT_PORT = 2525
+  DEFAULT_BACKLOG = 100
+  DEFAULT_BEHAVIOR = :blackhole
+  DEFAULT_HOSTNAME = "localhost"
+  TIMEOUT = 9
+end

data/lib/celluloid/smtp/extensions.rb

@@ -0,0 +1,7 @@
+module Celluloid::SMTP::Extensions
+  def self.included(object)
+    object.send(:include, Celluloid::SMTP::Constants)
+    object.extend Forwardable
+    object.def_delegators :"Celluloid::SMTP::Server.logger", :debug, :console, :warn, :error, :exception
+  end
+end

data/lib/celluloid/smtp/logging.rb

@@ -0,0 +1,18 @@
+class Celluloid::SMTP::Logging
+  include Celluloid
+
+  [:debug, :info, :warn, :error].each { |method|
+    define_method(method) { |*args| async.log(method,*args) }
+  }
+
+  alias :console :info
+
+  def log(method, *args)
+    Celluloid::SMTP::Constants::LOGGER.send(method,*args)
+  end
+
+  def exception(ex, note)
+    error("#{note}: #{ex} (#{ex.class})")
+    ex.backtrace.each { |line| error("* #{line}") }
+  end
+end

data/lib/celluloid/smtp/server.rb

@@ -0,0 +1,94 @@
+module Celluloid
+  module SMTP
+    class Server
+      include Celluloid::IO
+      class << self
+        @logger = nil
+        attr_accessor :logger
+        def launch(options)
+          unless @logger
+            Celluloid::SMTP::Logging.supervise as: :logger
+            @logger = Celluloid[:logger]
+          end
+          if SMTP::Constants::HANDLERS > 0
+            Celluloid::SMTP::Server::Handler.supervise as: :handler, size: SMTP::Constants::HANDLERS
+          end
+          supervise(as: :smtpd, args:[options])
+          Celluloid[:smtpd]
+        end
+        def run!(options={})
+          launch(options)
+        end
+        def run(options={})
+          launch(options)
+          sleep
+        end
+      end
+
+      finalizer :ceased
+
+      def ceased
+        @server.close rescue nil
+        warn "SMTP Server offline."
+      end
+
+      def initialize(options={})
+        @options = options
+        @host = options.fetch(:host, DEFAULT_HOST)
+        @port = options.fetch(:port, DEFAULT_PORT)
+        @behavior = options.fetch(:behavior, DEFAULT_BEHAVIOR)
+        @hostname = options.fetch(:hostname, DEFAULT_HOSTNAME)
+        @backlog = options.fetch(:backlog, DEFAULT_BACKLOG)
+
+        @server = Celluloid::IO::TCPServer.new(@host, @port)
+        @server.listen(options.fetch(:backlog, @backlog))
+
+        console("Celluloid::IO SMTP Server #{SMTP::VERSION} @ #{@host}:#{@port}")
+
+        @options[:rescue] ||= []
+        @options[:rescue] += [
+          Errno::ECONNRESET,
+          Errno::EPIPE,
+          Errno::EINPROGRESS,
+          Errno::ETIMEDOUT,
+          Errno::EHOSTUNREACH
+        ]
+        async.run
+      end
+
+      def shutdown
+        @online = false
+        sleep 0.126
+        @server.close if @server rescue nil
+      end
+
+      private
+
+      def run
+        console "Starting to handle SMTP connections, with #{HANDLERS} handlers."
+        @online = true
+        loop {
+          break unless @online
+          begin
+            socket = @server.accept
+          rescue *@options[:rescue] => ex
+            warn "Error accepting socket: #{ex.class}: #{ex.to_s}"
+            next
+          rescue IOError, EOFError
+            warn "I/O Error on socket: #{ex.class}: #{ex.to_s}"
+          end
+          async.connection(socket)
+        }
+      end
+
+      def connection(socket)
+        if HANDLERS > 0
+          Celluloid[:handler].socket(socket, @options)
+        else
+          self.class.protector(socket) { |io| Connection.new(io, @options) }
+        end
+      end
+
+    end
+  end
+end

data/lib/celluloid/smtp/server/handler.rb

@@ -0,0 +1,11 @@
+class Celluloid::SMTP::Server::Handler
+  include Celluloid
+  def socket(socket, options)
+    async.serve(socket,options)
+  end
+  def serve(socket, options)
+    SMTP::Server.protector(socket) { |io|
+      SMTP::Connection.new(io,options)
+    }
+  end
+end

data/lib/celluloid/smtp/server/protector.rb

@@ -0,0 +1,20 @@
+class Celluloid::SMTP::Server
+  class << self
+    include Celluloid::SMTP::Extensions
+    def protector(io)
+      Thread.new {
+        Timeout.timeout(TIMEOUT) {
+          yield(io)
+        }
+      }.value
+    rescue EOFError, IOError
+      warn "Premature disconnect."
+    rescue Timeout::Error
+      warn "Timeout handling connection."
+    rescue Exception => ex
+      exception(ex, "Unknown connection error")
+    ensure
+      io.close
+    end     
+  end
+end

data/lib/celluloid/smtp/server/transporter.rb

@@ -0,0 +1,9 @@
+class Celluloid::SMTP::Server::Transporter
+  include Celluloid::IO
+
+  def deliver(message)
+  end
+
+  def relay(message)
+  end
+end

data/lib/celluloid/smtp/version.rb

@@ -0,0 +1,3 @@
+module Celluloid::SMTP
+  VERSION = "0.9.0"
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: celluloid-smtp
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- digitalextremist //
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2015-06-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: mail
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A small, fast, evented, actor-based, highly customizable Ruby SMTP server.
+email: code@extremist.digital
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .gitmodules
+- CHANGES.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- celluloid-smtp.gemspec
+- events.rb
+- examples/basic_server.rb
+- examples/test_load.rb
+- examples/test_messages.rb
+- lib/celluloid/smtp.rb
+- lib/celluloid/smtp/connection.rb
+- lib/celluloid/smtp/connection/automata.rb
+- lib/celluloid/smtp/connection/errors.rb
+- lib/celluloid/smtp/connection/events.rb
+- lib/celluloid/smtp/connection/parser.rb
+- lib/celluloid/smtp/constants.rb
+- lib/celluloid/smtp/extensions.rb
+- lib/celluloid/smtp/logging.rb
+- lib/celluloid/smtp/server.rb
+- lib/celluloid/smtp/server/handler.rb
+- lib/celluloid/smtp/server/protector.rb
+- lib/celluloid/smtp/server/transporter.rb
+- lib/celluloid/smtp/version.rb
+homepage: https://github.com/abstractive/celluloid-smtp
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.4.6
+signing_key:
+specification_version: 4
+summary: Celluloid based SMTP server.
+test_files: []