RubyGems - bulkmail - Versions diffs - 0.1 → 0.3.0 - Mend

bulkmail 0.1 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

data/CHANGELOG +29 -1
data/README +21 -24
data/Rakefile +4 -3
data/bin/bulkmail +25 -39
data/doc/rdoc/created.rid +1 -0
data/lib/bulkmail/dns_mx.rb +18 -0
data/lib/bulkmail/message.rb +103 -0
data/lib/bulkmail/sender.rb +90 -0
data/lib/bulkmail/thread_pool.rb +113 -0
data/lib/bulkmail.rb +4 -75
metadata +10 -3

data/CHANGELOG CHANGED Viewed

@@ -1,3 +1,31 @@
+*0.3.0*
+* Connecting directly to the recipient's SMTP server.
+* Implemented Sender class that does the actual work.
+* Implemented Message and Message::MultiPart classes for composing messages.
+* Rewritten from the ground up.
+*0.2.1*
+* Added shuffling of addresses.
+* Fixed batch slicing to actually work.
+*0.2*
+* Updated README.
+* Set batch size at 10.
+* Fixed script to use new version.
+* Removed actionmailer dependancy.
+* Rewrote to use Net::SMTP directly.
 *0.1*
 * Add INT trap.
@@ -22,4 +50,4 @@
 * Preliminary content.
-* Created basic project structure.
+* Created basic project structure.

data/README CHANGED Viewed

@@ -1,6 +1,6 @@
-= about bulkmail
+= About Bulkmail
-Bulkmail is a simple bulk mailing utility in Ruby. It takes a content file and a recipients file, and sends the content to each address listed in the recipients file. I wrote it to be as simple as possible, and as a basic alternative to commercial bulk-mailers. The free ones suck.
+Bulkmail is a simple bulk mailing utility in Ruby. It takes a content file and a recipients file, and sends the content to each address listed in the recipients file. Bulkmail sends email by connecting directly to each recipient's SMTP server, and you therefore do not need your own SMTP server in order to send messages.
 == Usage
@@ -11,32 +11,29 @@ Bulkmail is a simple bulk mailing utility in Ruby. It takes a content file and a
 where the options are:
   [--recipients, -r] recipients file name
   [--content, -c] content file name
-  [--subject, -s] subject
   [--from, -f] from
-  [--host, -h] smtp hostname (if none is specified localhost is presumed)
-  [--user, -u] user name (if authentication is needed)
-  [--password, -p] password (if authentication is needed)
-  [--auth, -a] authentication type
-  [--mime, -m] message mime type.
+  [--helo, -h] SMTP HELO domain (most SMTP servers require you to identify with your domain)
-You can also include headers in the content file, provided they are followed by a blank line. For example:
+You should include headers in the content file. Remember that the headers should be followed by a blank link, followed by the message body. For example:
-  Subject: Baroque Concert this Thursday
+  Subject: My New Thing
+  From: myemail@mydomain.com
+  Content-Type: text/html; charset=UTF-8
-  Hello Baroque Lovers,
-    A special concert is about to take place this Thursday at...
+  <html><body><h1>My New Thing!</h1></body></html>
 === From Ruby
-BulkMail.send(options)
-Valid options are:
-  [:recipients_file] recipients file name
-  [:content_file] content file name
-  [:subject] subject
-  [:from] from
-  [:additional_headers] additional headers
-You can set server settings in the same fashion as ActionMailer by using the convenience method:
-  BulkMail.server_settings[:address] = 'mail.example.com'
+  msg = BulkMail::Message({
+    :from => 'myemail@mydomain.com',
+    :subject => 'nothing really'
+  }, 'hi there')
+  sender = BulkMail::Sender.new({
+    :list => addresses,
+    :from => 'myemail@mydomain.com',
+    :helo => 'mydomain.com',
+    :message => msg
+  })
+  sender.start

data/Rakefile CHANGED Viewed

@@ -7,7 +7,7 @@ require 'fileutils'
 include FileUtils
 NAME = "bulkmail"
-VERS = "0.1"
+VERS = "0.3.0"
 CLEAN.include ['**/.*.sw?', '*.gem', '.config']
 RDOC_OPTS = ['--quiet', '--title', "Bulkmail Documentation",
   "--opname", "index.html",
@@ -26,7 +26,7 @@ Rake::RDocTask.new do |rdoc|
   rdoc.options += RDOC_OPTS
   rdoc.main = "README"
   rdoc.title = "Bulkmail Documentation"
-  rdoc.rdoc_files.add ['README', 'CHANGELOG', 'COPYING', 'lib/*.rb']
+  rdoc.rdoc_files.add ['README', 'CHANGELOG', 'COPYING', 'lib/**/*']
 end
 spec = Gem::Specification.new do |s|
@@ -44,9 +44,10 @@ spec = Gem::Specification.new do |s|
   s.homepage = 'http://code.google.com/p/bulkmail/'
   s.executables = ['bulkmail']
-  s.add_dependency('actionmailer')
   s.required_ruby_version = '>= 1.8.2'
+  s.add_dependency('pNet-DNS')
   s.files = %w(COPYING README Rakefile) + Dir.glob("{bin,doc,lib}/**/*")
   s.require_path = "lib"

data/bin/bulkmail CHANGED Viewed

@@ -1,10 +1,16 @@
 #!/usr/bin/env ruby
+STDERR.reopen "/dev/null", "a"
+# We do this because pNet-DNS throws out a bunch of warnings
 require 'rubygems'
 require 'optparse'
+require 'bulkmail'
-config = {
-}
+$helo = nil
+$from = nil
+$recipients = []
+$content = nil
 opts = OptionParser.new do |opts|
   opts.banner = "Usage: bulkmail <options>"
@@ -12,42 +18,22 @@ opts = OptionParser.new do |opts|
   opts.separator ""
   opts.separator "Options:"
-  opts.on("-h", "--host HOSTNAME", "SMPT host name. Default is localhost.") do |v|
-    config[:host] = v
+  opts.on("-h", "--helo HOSTNAME", "HELO host name.") do |v|
+    $helo = v
   end
   opts.on("-r", "--recipients filename", "Recipients file name") do |v|
-    config[:recipients_file] = v
+    $recipients = IO.readlines(v).map {|l| l =~ /(.*)(\r\n|\n)$/ ? $1 : l}.compact
   end
   opts.on("-c", "--content filename", "Content file name") do |v|
-    config[:content_file] = v
-  end
-  opts.on("-s", "--subject subject", "Subject line") do |v|
-    config[:subject] = v
+    $content = IO.read(v)
   end
   opts.on("-f", "--from from", "From address") do |v|
-    config[:from] = v
-  end
-  opts.on("-u", "--user username", "User name (for authentication)") do |v|
-    config[:user] = v
-  end
-  opts.on("-p", "--password password", "Password (for authentication)") do |v|
-    config[:password] = v
+    $from = v
   end
-  opts.on("-a", "--authentication type", "Authentication type") do |v|
-    config[:authentication] = v
-  end
-  opts.on("-m", "--mime type", "MIME type") do |v|
-    config[:content_type] = v
-  end
   # No argument, shows at tail.  This will print an options summary.
   # Try it and see!
   opts.on_tail("-?", "--help", "Show this message") do
@@ -68,24 +54,24 @@ begin
   opts.parse! ARGV
 rescue => e
   puts e.message
+  puts e.backtrace.first
   exit
 end
-unless config[:recipients_file] && config[:content_file]
+unless $content
   puts opts
   exit
 end
-require 'bulkmail'
-BulkMail.server_settings[:address] = config[:host] if config[:host]
-BulkMail.server_settings[:user_name] = config[:user] if config[:user]
-BulkMail.server_settings[:password] = config[:password] if config[:password]
-BulkMail.server_settings[:authentication] = config[:authentication].to_sym if config[:authentication]
+trap('INT') {exit}
-p BulkMail.server_settings
+puts "Please hold on..."
-job = BulkMail.send(config)
-trap('INT') {job.thread.exit;}
-job.thread.join
-puts "Message sent to #{job.delivered} of #{job.total} recipients."
+sender = BulkMail::Sender.new({
+  :list => $recipients,
+  :from => $from,
+  :message => $content,
+  :helo => $helo
+})
+sender.start

data/doc/rdoc/created.rid ADDED Viewed

	@@ -0,0 +1 @@
1	+ Mon Nov 06 23:13:08 +0200 2006

data/lib/bulkmail/dns_mx.rb ADDED Viewed

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'net/smtp'
+require 'net/dns'
+module BulkMail
+  # Performs a DNS query for a domain's MX records and returns an array
+  # of SMTP servers for the domain ordered by preference. If no records
+  # are found an error is raised.
+  def self.smtp_servers_for_domain(domain)
+    res = Net::DNS::Resolver.new
+    mx = Net::DNS.mx(domain, res, 'IN')
+    if mx
+      mx.sort {|x,y| y.preference <=> x.preference}.map {|rr| rr.exchange}
+    else
+      raise RuntimeError, "Could not locate MX records for domain #{domain}."
+    end
+  end
+end

data/lib/bulkmail/message.rb ADDED Viewed

@@ -0,0 +1,103 @@
+# Symbol extensions
+class Symbol
+  # Returns the symbol as a header string
+  def to_header
+    return @to_header if @to_header
+    s = to_s
+    @to_header = (s.upcase == s) ? s :
+      to_s.split('_').map{|w| w.capitalize}.join('-')
+  end
+end
+class String
+  alias_method :to_header, :to_s
+end
+module BulkMail
+  # The Message class can be used to compose email messages with headers. Usage
+  # is pretty straightforward:
+  #
+  #   m = BulkMail::Message.new({:from => my_email, :subject => 'hello'},
+  #     'Hi there!')
+  class Message
+    attr_accessor :headers, :body
+    DEFAULT_HEADERS = {
+      :mime_version => '1.0'
+    }
+    PLAIN = 'text/plain; charset=UTF-8'.freeze
+    HTML = 'text/html; charset=UTF-8'.freeze
+    # Creates a new message, including the default headers in the message headers.
+    def initialize(headers, body)
+      @headers = DEFAULT_HEADERS.merge(headers)
+      @body = body
+    end
+    LINE_BREAK = "\r\n"
+    HEADER_FMT = "%s: %s\r\n".freeze
+    # Formats the message headers into a string.
+    def self.format_headers(headers)
+      headers.inject('') do |m, kv|
+        if kv[1]
+          m << (HEADER_FMT % [kv[0].to_header, kv[1]])
+        else
+          m
+        end
+      end
+    end
+    # Composes the header and body into a message string.
+    def to_s
+      msg = Message.format_headers(@headers)
+      msg << LINE_BREAK
+      msg << body
+      msg
+    end
+  end
+  # The MultiPart class can be used for composing multi-part messages. For
+  # example:
+  #
+  #   m = BulkMail::Message::MultiPart.new(
+  #     {:from => 'my_email', :subject => 'Hello'}, :alternate)
+  #   m.add_part({:content_type => BulkMail::Message::PLAIN},
+  #     'You are now seeing the plain text version')
+  #   m.add_part({:content_type => BulkMail::Message::HTML},
+  #     '<p>You are now seeing the HTML version</p>')
+  #   puts m.to_s
+  class Message::MultiPart < Message
+    attr_accessor :parts, :multi_type
+    # Initializes a new instance.
+    def initialize(headers, multi_type)
+      super(headers, nil)
+      @multi_type = multi_type
+      @parts = []
+    end
+    # Adds a part to the message.
+    def add_part(headers, body)
+      @parts << Message.new(headers, body)
+    end
+    BOUNDARY = '!!@@##$$'.freeze
+    MULTI_PART_CONTENT_TYPE_FMT = "multipart/%s; charset=UTF-8; boundary=\"#{BOUNDARY}\"".freeze
+    BOUNDARY_LINE = "\r\n--#{BOUNDARY}\r\n".freeze
+    # Composes the parts into an email message.
+    def to_s
+      @headers[:content_type] = MULTI_PART_CONTENT_TYPE_FMT % @multi_type
+      msg = Message.format_headers(@headers)
+      @parts.each do |part|
+        msg << BOUNDARY_LINE
+        msg << part.to_s
+      end
+      msg << BOUNDARY_LINE
+      msg
+    end
+  end
+end

data/lib/bulkmail/sender.rb ADDED Viewed

@@ -0,0 +1,90 @@
+require 'net/smtp'
+module BulkMail
+  # Sender instances perform the actual work of sending an email. Each sender
+  # sets up a thread pool (by default with up to 20 threads) for performing the
+  # work. When creating a Sender instance, a hash of options is supplied:
+  #
+  #   BulkMail::Sender.new({
+  #     :list => addresses,
+  #     :from => my_address,
+  #     :helo => my_helo_domain,
+  #     :concurrent => 50, # size of thread pool
+  #     :message => message
+  #   })
+  #
+  # To start sending, invoke Sender#start. The start method will block until
+  # all addresses have been processed.
+  class Sender
+    # Initializes a new instance with the supplied options hash, and creates a
+    # thread pool (with a default maximum size of 20).
+    def initialize(opts)
+      @opts = opts
+      @pool = ThreadPool.new(@opts[:concurrent] || 20)
+      @smtp_servers = {}
+      @mutex = Mutex.new
+    end
+    # Starts processing the addresses by sending each one a message, and waits
+    # for the thread pool to finish its work.
+    def start
+      @opts[:list].each {|a| @pool.process {send(a)}}
+      @pool.join
+    end
+    # returns an array of SMTP servers for the email address. If an invalid
+    # address is specified, an error is raised. SMTP servers for each email
+    # domain are memoized to improve performance.
+    def smtp_servers_for_addr(addr)
+      if (addr =~ /<(.*)@(.*)>/) or (addr =~ /(.*)@(.*)/)
+        domain = $2
+      else
+        raise RuntimeError, "Invalid email address."
+      end
+      @mutex.synchronize do
+        @smtp_servers[domain] ||= BulkMail.smtp_servers_for_domain(domain)
+      end
+    end
+    # Sends an email to a recipient by trying any of the SMTP servers available
+    # for the recipient.
+    def send(addr)
+      servers = smtp_servers_for_addr(addr)
+      if servers.empty?
+        report_addr(addr, :error, 'Unknown domain')
+        return
+      end
+      servers.each do |server|
+        begin
+          send_message(server, addr)
+          report_addr(addr, :success)
+          return
+        rescue => e
+          report_addr(addr, :error, e.message)
+        end
+      end
+    end
+    # Opens a connection to an SMTP server and sends the message.
+    def send_message(server, addr)
+      Net::SMTP.start(
+        server, nil, @opts[:helo], nil, nil, nil) do |smtp|
+        smtp.send_message @opts[:message].to_s, @opts[:from], addr
+      end
+    end
+    # Reports success or failure for the recipient.
+    def report_addr(addr, status, error = nil)
+      @mutex.synchronize do
+        case status
+        when :success:
+          puts "Sent mail to #{addr}"
+          File.open('sent.bulkmail', 'a') {|f| f.puts "#{addr}"}
+        when :error:
+          puts "Failed to send to #{addr}: #{error}"
+          File.open('failed.bulkmail', 'a') {|f| f.puts "#{addr}: #{error}"}
+        end
+      end
+    end
+  end
+end

data/lib/bulkmail/thread_pool.rb ADDED Viewed

@@ -0,0 +1,113 @@
+require 'thread'
+# This class implements a pool of threads. The pool hands out blocks to be
+# processed to any available worker thread. If no worker thread is available,
+# the pool blocks until any of the workers have become available. The pool
+# size can be specified when constructing the pool. For exmaple:
+#
+#   pool = ThreadPool.new(10)
+#   10.times {pool.process {sleep 3}}
+#   10.times {pool.process {sleep 3}} # this will block for about 3 seconds.
+#   pool.join # this will block for about 3 more seconds.
+class ThreadPool
+  # The Worker class starts a thread for performing work. A worker thread
+  # sleeps until it receives a block for processing, at which time it is
+  # considered busy. Once the block has been processed, the worker is
+  # considered available again.
+  class Worker
+    # Starts the worker thread.
+    def initialize
+      @mutex = Mutex.new
+      @thread = Thread.new do
+        while true
+          sleep 0.001
+          block = get_block
+          if block
+            block.call
+            reset_block
+          end
+        end
+      end
+    end
+    # Returns the block to be processed, if any.
+    def get_block
+      @mutex.synchronize {@block}
+    end
+    # Sets the block to be processed.
+    def set_block(block)
+      @mutex.synchronize {@block = block}
+    end
+    # Resets the block instance variable to signify that the worker
+    # is available.
+    def reset_block
+      @mutex.synchronize {@block = nil}
+    end
+    # Returns true if the worker is busy processing a block.
+    def busy?
+      @mutex.synchronize {!@block.nil?}
+    end
+  end
+  attr_accessor :max_size
+  attr_reader :workers
+  # Creates a new pool with a default maximum size of 10.
+  def initialize(max_size = 10)
+    @max_size = max_size
+    @workers = []
+    @mutex = Mutex.new
+  end
+  # Returns the number of workers in the pool.
+  def size
+    @mutex.synchronize {@workers.size}
+  end
+  # Returns true if any of the workers in the pool are busy.
+  def busy?
+    @mutex.synchronize {@workers.any? {|w| w.busy?}}
+  end
+  # Blocks until all workers have become available.
+  def join
+    sleep 0.01 while busy?
+  end
+  # Hands the block to an available worker. If no workers are available, this
+  # method will block until one becomes available.
+  def process(&block)
+    wait_for_worker.set_block(block)
+  end
+  # Waits for a worker to become available.
+  def wait_for_worker
+    while true
+      worker = find_available_worker
+      return worker if worker
+      sleep 0.01
+    end
+  end
+  # Returns an available worker or a new worker if the maximum pool size
+  # has not been reached.
+  def find_available_worker
+    @mutex.synchronize {free_worker || create_worker}
+  end
+  # Returns the first available worker.
+  def free_worker
+    @workers.each {|w| return w unless w.busy?}; nil
+  end
+  # Creates a worker if the maximum pool size has not been reached.
+  def create_worker
+    return nil if @workers.size >= @max_size
+    worker = Worker.new
+    @workers << worker
+    worker
+  end
+end

data/lib/bulkmail.rb CHANGED Viewed

@@ -1,75 +1,4 @@
-require 'action_mailer'
-# The BulkMail module contains the Job class, which does the actual
-# bulk-mailing, and a convenience method to start a job.
-module BulkMail
-  class Mailer < ActionMailer::Base #:nodoc
-    def msg(addr, sub, content, from_addr, c_type, additional_headers)
-      recipients addr
-      subject sub if sub
-      body content
-      from from_addr if from_addr
-      content_type c_type if c_type
-      headers additional_headers if additional_headers
-    end
-  end
-  # The Job class performs the bulk-mailing work. Each instance starts a thread
-  # That goes over the list of recipients and sends each one an email. A job
-  # can also be queried for its progress, returning a number between 0 and 1.
-  class Job
-    attr_accessor :progress, :errors, :thread, :delivered, :total
-    def initialize(opts)
-      @recipients = IO.readlines(opts[:recipients_file])
-      @subject = opts[:subject]
-      @from = opts[:from]
-      @content_type = opts[:content_type]
-      @content = load_content(opts[:content_file])
-      @progress = 0
-      @delivered = 0
-      @total = @recipients.size
-      @errors = []
-      @thread = Thread.new {process}
-    end
-    def load_content(fn)
-      content = IO.readlines(fn)
-      while line = content.shift
-        break if line.empty?
-        if line =~ /^(.+):\s?(.*)$/
-          @headers ||= {}
-          @headers[$1] = $2
-        else
-          content.unshift(line)
-          break
-        end
-      end
-      content.join
-    end
-    def process
-      @recipients.each_with_index do |addr, idx|
-        begin
-          Mailer.deliver_msg(addr, @subject, @content, @from, @content_type, @headers)
-          @progress = idx / @recipients.size
-          @delivered += 1
-          puts "Sent email to #{addr}"
-        rescue => e
-          puts e.message
-          @errors << e
-        end
-      end
-      @progress = 1
-    end
-  end
-  def self.send(opts)
-    Job.new(opts)
-  end
-  def self.server_settings
-    ActionMailer::Base.server_settings
-  end
-end
+require File.join(File.dirname(__FILE__), 'bulkmail/thread_pool')
+require File.join(File.dirname(__FILE__), 'bulkmail/dns_mx')
+require File.join(File.dirname(__FILE__), 'bulkmail/message')
+require File.join(File.dirname(__FILE__), 'bulkmail/sender')

metadata CHANGED Viewed

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: bulkmail
 version: !ruby/object:Gem::Version
-  version: "0.1"
-date: 2006-10-18 00:00:00 +02:00
+  version: 0.3.0
+date: 2007-01-12 00:00:00 +02:00
 summary: Ruby bulk-mailer.
 require_paths:
 - lib
@@ -33,7 +33,14 @@ files:
 - README
 - Rakefile
 - bin/bulkmail
+- doc/rdoc
+- doc/rdoc/created.rid
+- lib/bulkmail
 - lib/bulkmail.rb
+- lib/bulkmail/dns_mx.rb
+- lib/bulkmail/message.rb
+- lib/bulkmail/sender.rb
+- lib/bulkmail/thread_pool.rb
 - CHANGELOG
 test_files: []
@@ -63,7 +70,7 @@ requirements: []
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: actionmailer
+  name: pNet-DNS
   version_requirement:
   version_requirements: !ruby/object:Gem::Version::Requirement
     requirements: