stompserver 0.9.7 → 0.9.8

data/History.txt

@@ -1,9 +1,11 @@
-== 0.9.6 / 31 Oct 2006
-
-* Added simple code to handle denial of service attacks from large headers
-* Fixed a multitude of bugs (and added tests) found by our small but growing 
-  community of users
-* more coming soom (thanks to snacktime)
+== 0.9.8 / 16 Aug 2007
+
+* Several storage backends instead of Madeleine (allow tradeoffs between
+  robustness with ActiveRecord and speed with memory with intermediary
+  solutions based on file or dbm storages).
+* Better load distribution between clients acknowledging messages after
+  processing them.
+* Monitoring support through a dedicated queue.
 
 == 0.9.5 / 18 Oct 2006
 

data/Manifest.txt

@@ -2,15 +2,33 @@ History.txt
 Manifest.txt
 README.txt
 Rakefile
-setup.rb
+STATUS
 bin/stompserver
-lib/frame_journal.rb
-lib/queue_manager.rb
-lib/stomp_frame.rb
+client/README.txt
+client/both.rb
+client/consume.rb
+client/send.rb
+config/stompserver.conf
+etc/passwd.example
 lib/stomp_server.rb
-lib/topic_manager.rb
-test/test_frame_journal.rb
+lib/stomp_server/protocols/http.rb
+lib/stomp_server/protocols/stomp.rb
+lib/stomp_server/queue.rb
+lib/stomp_server/queue/activerecord_queue.rb
+lib/stomp_server/queue/ar_message.rb
+lib/stomp_server/queue/dbm_queue.rb
+lib/stomp_server/queue/file_queue.rb
+lib/stomp_server/queue/memory_queue.rb
+lib/stomp_server/queue_manager.rb
+lib/stomp_server/stomp_auth.rb
+lib/stomp_server/stomp_frame.rb
+lib/stomp_server/stomp_id.rb
+lib/stomp_server/stomp_user.rb
+lib/stomp_server/test_server.rb
+lib/stomp_server/topic_manager.rb
+setup.rb
+test/tesly.rb
 test/test_queue_manager.rb
 test/test_stomp_frame.rb
-test/test_stomp_server.rb
 test/test_topic_manager.rb
+test_todo/test_stomp_server.rb

data/README.txt

@@ -1,43 +1,160 @@
 stompserver
-    by Patrick Hurley
+    by Patrick Hurley, Lionel Bouton
     http://stompserver.rubyforge.org/
 
 == DESCRIPTION:
 
-Don't want to install a JVM, but still want to use messaging? Me too,
-so I threw together this little server. All the hard work was done
-by Francis Cianfrocca (big thank you) in his event machine gem (which
-is required by this server).
+Stomp messaging server with file/dbm/memory/activerecord based FIFO
+queues, queue monitoring, and basic authentication.
 
-== FEATURES/PROBLEMS:
+== SYNOPSYS:
 
 Handles basic message queue processing
-Does not support any server to server messaging
-  (although you could write a client to do this)
-Server Id is not being well initialized   
-Quite a bit of polish is still required to make into a daemon/service 
-And oh yeah, I need to write some docs (see the tests for now)
 
-== SYNOPSYS:
+== REQUIREMENTS:
 
-Handles basic message queue processing  
+* EventMachine
 
-== REQUIREMENTS:
+== FEATURES/PROBLEMS:
+
+=== Several queue storage backends
+
+Handles basic message queue processing using memory, file, or dbm
+based queues. Messages are sent and consumed in FIFO order (unless a
+client error happens, this should be corrected in the future). Topics
+are memory-only storage.  You can select activerecord, file or dbm
+storage and the queues will use that, but topics will only be stored
+in memory.
+
+memory queues are of course the fastest ones but shouldn't be used if
+you want to ensure all messages are delivered.
+
+dbm queues will use berkeleydb if available, otherwise dbm or gdbm
+depending on the platform. sdbm does not work well with marshalled
+data. Note that these queues have not been tested in this release.
+
+For the file based storage, each frame is stored in a single file. The
+first 8 bytes contains the header length, the next 8 bytes contains
+the body length, then the headers are stored as a marshalled object
+followed by the body stored as a string. This storage is currently
+inefficient because queues are stored separately from messages, which
+forces a double write for data safety reasons on each message stored.
+
+The activerecord based storage expects to find a database.yml file in
+the configuration directory. It should be the most robust backend, but
+the slowest one. The database must have an ar_messages table which can
+be created with the following code (you are responsible to do so):
+
+  ActiveRecord::Schema.define do
+    create_table 'ar_messages' do |t|
+      t.column 'stomp_id', :string, :null => false
+      t.column 'frame', :text, :null => false
+    end
+  end
+
+You can read the frames with this model:
+
+  class ArMessage < ActiveRecord::Base
+    serialize :frame
+  end
+
+The ar_message implementation will certainly change in the future.
+
+This is meant to be easily readable by a Rails application (which
+could handle the ar_messages table creation with a migration).
+
+=== Limitations
+
+Stompserver not support any server to server messaging (although you could
+write a client to do this).
+
+=== Monitoring
+
+Queues can be monitored via the monitor queue (this will probably not
+be supported this way in the future to avoid polluting the queue
+namespace). If you subscribe to /queue/monitor, you will receive a
+status message every 5 seconds that displays each queue, it's size,
+frames enqueued, and frames dequeued. Stats are sent in the same
+format of stomp headers, so they are easy to parse. Following is an
+example of a status message containing stats for 2 queues:
+
+Queue: /queue/client2
+size: 0
+dequeued: 400
+enqueued: 400
+
+Queue: /queue/test
+size: 50
+dequeued: 250
+enqueued: 300
+
+=== Access control
+
+Basic client authorization is also supported.  If the -a flag is
+passed to stompserver on startup, and a .passwd file exists in the run
+directory, then clients will be required to provide a valid login and
+passcode.  See passwd.example for the password file format.
+
+=== Misc
 
-+ EventMachine
-+ madeleine 
+Whenever you stop the server, any queues with no messages will be
+removed, and the stats for that queue will be reset.  If the queue has
+any messages remaining then the stats will be saved and available on
+the next restart.
 
 == INSTALL:
 
-+ Grab the gem
-  and run:
-    stompserver -p 61613 -b 0.0.0.0 -j /var/ss/journal_dir
+* gem install stompserver
+
+stompserver will create a log, etc, and storage directory on startup
+in your current working directory, the value passed to as
+--working_dir parameter, or if using a config file it will
+use what you specified for working_dir.  The configuration file is a
+yaml file and can be specified on the command line with -C
+<configfile>. A sample is provided in config/stompserver.conf.
+
+Command line options will override options set in the yaml config
+file.
+
+To use the memory queue run as follows:
+  stompserver -p 61613 -b 0.0.0.0
+
+To use the file or dbm queue storage, use the -q switch and specificy
+either file or dbm.  The file and dbm queues also take a storage
+directory specified with -s.  .stompserver is the default directory if
+-s is not used.
+  stompserver -p 61613 -b 0.0.0.0 -q file -s .stompfile
+Or
+  stompserver -p 61613 -b 0.0.0.0 -q dbm -s .stompbdb
+
+To specify where the queue is stored on disk, use the -s flag followed
+by a storage directory.  To enable client authorization use -a, for
+debugging use -d.
+  stompserver -p 61613 -b 0.0.0.0 -q file -s .stompserver -a -d
+
+You cannot use the same storage directory for a file and dbm queue,
+they must be kept separate.
+
+To use the activerecord queue storage use -q activerecord:
+  stompserver -p 61613 -b 0.0.0.0 -q activerecord
+It will try to read the etc/database.yml file in the working
+directory. Here's an example of a database.yml for a PostgreSQL
+database named stompserver on the 'dbserver' host usable by
+PostgreSQL's user 'foo' with password 'bar'(see ActiveRecord's
+documentation for the parameters needed by your database):
+
+  adapter: postgresql
+  database: stompserver
+  username: foo
+  password: bar
+  host: dbserver
 
 == LICENSE:
 
 (The MIT License)
 
 Copyright (c) 2006 Patrick Hurley
+Copyright (c) 2007 Lionel Bouton
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/Rakefile

@@ -11,15 +11,15 @@ Hoe.new('stompserver', StompServer::VERSION) do |p|
   p.description = p.paragraphs_of('README.txt', 2..4).join("\n\n")
   p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
   p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
-  p.email = "phurley@gmail.com"
-  p.author = ["Patrick Hurley"]  
+  p.email = [ "lionel-dev@bouton.name" ]
+  p.author = [ "Lionel Bouton" ]
   p.extra_deps = [
-              # This depencency is real, but if you are on a Win32 box
-              # and don't have VC6, it can be a real problem
-              #    ["eventmachine", ">= 0.5.0"],
-                  ["madeleine", ">= 0.7.3"], 
-                  ["hoe", ">= 1.1.1"]
-                 ]
+    # This depencency is real, but if you are on a Win32 box
+    # and don't have VC6, it can be a real problem
+    ["daemons", ">= 1.0.2"],
+    ["hoe", ">= 1.1.1"],
+  ]
+  p.remote_rdoc_dir = ''
 end
 
 # vim: syntax=Ruby

data/STATUS

@@ -0,0 +1,5 @@
+
+- Unit tests are broken, need to override methods that call EM 
+- Added http protocol handler.  No pipelining or anything fancy, just PUT/GET requests which enqueue/dequeue messages from
+  the queue one at a time.  Uses the Mongrel http parser.
+

data/bin/stompserver

@@ -1,28 +1,52 @@
 require 'rubygems'
+require 'etc'
+require 'yaml'
+require 'daemons/daemonize'
 require 'stomp_server'
-require 'frame_journal'
 require 'optparse'
 
-opts = OptionParser.new
+$STOMP_SERVER = true
 
-port = 61613
-bind = "127.0.0.1"
-bind = "localhost"
-journal = ".stompserver"
-
-opts.on("-p", "--port=PORT", Integer, "Change the port (default: 61613)") {|p| port = p}
-opts.on("-b", "--bind=ADDR", String, "Change the binding adapter (default: localhost)") {|a| bind = a}
-opts.on("-j", "--journal=DIR", String, "Change the journal directory (default: ./.stompserver)") {|j| journal = j}
-opts.on("-d", "--debug", "Enable debug output") {$DEBUG=1}
-opts.on("-h", "--help", "Show this message") do
-  puts opts
-  exit
+$HTTP_ENABLE = false
+if $HTTP_ENABLE
+  require 'mongrel'
+  require 'stomp_server/protocols/http'
 end
 
-puts opts.parse(ARGV)
- 
-StompServer.setup(FrameJournal.new(journal))
+
 EventMachine::run do
-  puts "Stomp Server starting on port #{port}"
-  EventMachine.start_server bind, port, StompServer
+
+  ## Get the configuration and initialize the stomp engine
+  config = StompServer::Configurator.new
+  stomp = StompServer::Run.new(config.opts)
+  stomp.start
+
+
+  # Might want to uncomment this if you are sending large files
+  #EventMachine::add_periodic_timer 10, proc {GC.start}
+  
+  puts "Client authorization enabled" if config.opts[:auth]
+  puts "Debug enabled" if config.opts[:debug]
+
+  ## Start protocol handlers
+
+  puts "Stomp protocol handler starting on #{config.opts[:host]} port #{config.opts[:port]}"
+  EventMachine.start_server(config.opts[:host], config.opts[:port], StompServer::Protocols::Stomp) {|s| s.instance_eval {
+      @@auth_required=stomp.auth_required
+      @@queue_manager=stomp.queue_manager
+      @@topic_manager=stomp.topic_manager
+      @@stompauth = stomp.stompauth
+    }
+  }
+
+  if $HTTP_ENABLE
+    puts "Http protocol handler starting on #{config.opts[:host]} port 8080"
+    EventMachine.start_server(config.opts[:host], 8080, StompServer::Protocols::Http) {|s| s.instance_eval {
+        @@auth_required=stomp.auth_required
+        @@queue_manager=stomp.queue_manager
+        @@topic_manager=stomp.topic_manager
+        @@stompauth = stomp.stompauth
+      }
+    }
+  end
 end

data/client/README.txt

@@ -0,0 +1 @@
+Samples of how to use the ruby stomp client with stompserver

data/client/both.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'stomp'
+client = Stomp::Client.open "login", "passcode", "localhost", 61613
+
+client.subscribe("/queue/client2", {
+              "persistent" => true,
+              "ack" => 'client',
+              "client-id" => "rubyClient",
+        } ) do |message|
+  puts "Got Reply: #{message.headers['message-id']} - #{message.body} on #{message.headers['destination']}"
+end
+
+for i in 1..5 do
+   m = "Go Sox #{i}!"
+   puts m
+   client.send("/queue/client2", m, {
+    "persistent" => true,
+    "priority" => 4,
+    "reply-to" => "/queue/client2",
+    }
+  )
+end
+
+gets
+client.close

data/client/consume.rb

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'stomp'
+client = Stomp::Client.open "login", "passcode", "localhost", 61613
+
+client.subscribe("/queue/test", {
+                "persistent" => true,
+                "client-id" => "rubyClient",
+        } ) do |message|
+  puts "Got Reply: ID=#{message.headers['message-id']} BODY=#{message.body} on #{message.headers['destination']}"
+end
+
+
+gets
+client.close

data/client/send.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'stomp'
+client = Stomp::Client.open "login", "passcode", "localhost", 61613
+
+# sending 5 messages at once
+for i in 1..5 do
+   m = "Go Sox #{i}!"
+   puts m
+   client.send("/queue/test", m, {
+    "persistent" => true,
+    "client-id" => "Client1",
+    "reply-to" => "/queue/test",
+    }
+  )
+end
+
+client.close

data/config/stompserver.conf

@@ -0,0 +1,11 @@
+---
+:daemon: false
+:working_dir: /tmp/stompserver
+:storage: .queue
+:queue: file
+:auth: false
+:debug: false
+:group:
+:user:
+:host: 127.0.0.1
+:port: 61613

data/etc/passwd.example

@@ -0,0 +1,3 @@
+# Stompserver will look for a .passwd file in the directory you are running it from.  One login/passcode per line, separated by a colon.
+# Comment lines are ignored
+testuser:testpass

data/lib/stomp_server.rb

@@ -1,172 +1,147 @@
 require 'rubygems'
 require 'eventmachine'
-require 'stomp_frame'
-require 'topic_manager'
-require 'queue_manager'
-require 'frame_journal'
+require 'stomp_server/stomp_frame'
+require 'stomp_server/stomp_id'
+require 'stomp_server/stomp_auth'
+require 'stomp_server/topic_manager'
+require 'stomp_server/queue_manager'
+require 'stomp_server/queue'
+require 'stomp_server/queue/memory_queue'
+require 'stomp_server/queue/file_queue'
+require 'stomp_server/queue/dbm_queue'
+require 'stomp_server/protocols/stomp'
 
 module StompServer
-  VERSION = '0.9.7'
-  VALID_COMMANDS = [:connect, :send, :subscribe, :unsubscribe, :begin, :commit, :abort, :ack, :disconnect]
+  VERSION = '0.9.8'
 
-  def self.setup(j = FrameJournal.new, tm = TopicManager.new, qm = QueueManager.new(j))
-    @@journal = j
-    @@topic_manager = tm
-    @@queue_manager = qm
-  end
-    
-  def post_init
-    @sfr = StompFrameRecognizer.new
-    @transactions = {}
-    @connected = false
-  end
-  
-  def receive_data(data)
-    begin
-      puts "receive_data: #{data.inspect}" if $DEBUG
-      @sfr << data
-      process_frames
-    rescue Exception => e
-      puts "err: #{e} #{e.backtrace.join("\n")}" if $DEBUG
-      send_error(e.to_s)
-      close_connection_after_writing
-    end
-  end
-  
-  def process_frames
-    frame = nil
-    process_frame(frame) while frame = @sfr.frames.shift
-  end
-  
-  def process_frame(frame)
-    cmd = frame.command.downcase.to_sym
-    raise "Unhandled frame: #{cmd}" unless VALID_COMMANDS.include?(cmd)
-    raise "Not connected" if !@connected && cmd != :connect
-
-    puts "process_frame #{cmd}" if $DEBUG
-
-    # I really like this code, but my needs are a little trickier
-    # 
-
-    if trans = frame.headers['transaction']
-      handle_transaction(frame, trans, cmd)
-    else
-      cmd = :sendmsg if cmd == :send
-      puts "Execute #{cmd}" if $DEBUG
-      send(cmd, frame) 
-    end
-    
-    send_receipt(frame.headers['receipt']) if frame.headers['receipt']
-  end
+  class Configurator
+    attr_accessor :opts
+
+    def initialize
+      @opts = nil
+      @defaults = {
+        :port => 61613,
+        :host => "127.0.0.1",
+        :debug => false,
+        :queue => 'memory',
+        :auth => false,
+        :working_dir => Dir.getwd,
+        :storage => ".stompserver",
+        :logdir => 'log',
+        :configfile => 'stompserver.conf',
+        :logfile => 'stompserver.log',
+        :pidfile => 'stompserver.pid'
+      }
+      @opts = getopts
+      if opts[:debug]
+        $DEBUG=true
+      end
 
-  # here is how we can stop, of course there is currently no
-  # way to get here  
-  def shutdown(msg)
-    EventMachine::stop_event_loop
-  end
-  
-  def handle_transaction(frame, trans, cmd)
-    if [:begin, :commit, :abort].include?(cmd)
-      send(cmd, frame, trans)
-    else
-      raise "transaction does not exist" unless @transactions.has_key?(trans)
-      @transactions[trans] << frame
-    end    
-  end
-  
-  def connect(frame)
-    puts "Connecting" if $DEBUG
-    response = StompFrame.new("CONNECTED", {'session' => 'wow'})
-    send_data(response.to_s)
-    @connected = true
-  end
-  
-  def sendmsg(frame)
-    # set message id
-    frame.headers['message-id'] = "msg-#{@@journal.system_id}-#{@@journal.next_index}"
-    if frame.dest.match(%r|^/queue|)
-      @@queue_manager.sendmsg(frame)
-    else
-      @@topic_manager.sendmsg(frame)
     end
-  end
-  
-  def subscribe(frame)
-    if frame.dest =~ %r|^/queue|
-      ack = frame.headers['ack'] == 'client'
-      @@queue_manager.subscribe(frame.dest, self, ack) 
-    else
-      @@topic_manager.subscribe(frame.dest, self)
+
+    def getopts
+      copts = OptionParser.new
+      copts.on("-C", "--config=CONFIGFILE", String, "Configuration File (default: stompserver.conf)") {|c| @defaults[:configfile] = c}
+      copts.on("-p", "--port=PORT", Integer, "Change the port (default: 61613)") {|p| @defaults[:port] = p}
+      copts.on("-b", "--host=ADDR", String, "Change the host (default: localhost)") {|a| @defaults[:host] = a}
+      copts.on("-q", "--queuetype=QUEUETYPE", String, "Queue type (memory|dbm|activerecord|file) (default: memory)") {|q| @defaults[:queue] = q}
+      copts.on("-w", "--working_dir=DIR", String, "Change the working directory (default: current directory)") {|s| @defaults[:working_dir] = s}
+      copts.on("-s", "--storage=DIR", String, "Change the storage directory (default: .stompserver, relative to working_dir)") {|s| @defaults[:storage] = s}
+      copts.on("-d", "--debug", String, "Turn on debug messages") {|d| @defaults[:debug] = true}
+      copts.on("-a", "--auth", String, "Require client authorization") {|a| @defaults[:auth] = true}
+      copts.on("-h", "--help", "Show this message") do
+        puts copts
+        exit
+      end
+      puts copts.parse(ARGV)
+
+      if File.exists?(@defaults[:configfile])
+        opts = @defaults.merge(YAML.load_file(@defaults[:configfile]))
+      else
+        opts = @defaults
+      end
+
+      opts[:etcdir] = File.join(opts[:working_dir],'etc')
+      opts[:storage] = File.join(opts[:working_dir],opts[:storage])
+      opts[:logdir] = File.join(opts[:working_dir],opts[:logdir])
+      opts[:logfile] = File.join(opts[:logdir],opts[:logfile])
+      opts[:pidfile] = File.join(opts[:logdir],opts[:pidfile])
+      if opts[:auth]
+        opts[:passwd] = File.join(opts[:etcdir],'.passwd')
+      end
+
+      return opts
     end
   end
-  
-  def unsubscribe(frame)
-    if frame.dest =~ %r|^/queue|
-      @@queue_manager.unsubscribe(frame.dest, self)
-    else
-      @@topic_manager.unsubscribe(frame.dest, self)
+
+
+  class Run
+    attr_accessor :queue_manager, :auth_required, :stompauth, :topic_manager
+
+    def initialize(opts)
+      @opts = opts
+      @queue_manager = nil
+      @auth_required = nil
+      @stompauth = nil
+      @topic_manager = nil
     end
-  end
-  
-  def begin(frame, trans=nil)
-    raise "Missing transaction" unless trans
-    raise "transaction exists" if @transactions.has_key?(trans)
-    @transactions[trans] = []
-  end
-  
-  def commit(frame, trans=nil)
-    raise "Missing transaction" unless trans
-    raise "transaction does not exist" unless @transactions.has_key?(trans)
-    
-    (@transactions[trans]).each do |frame|
-      frame.headers.delete('transaction')
-      process_frame(frame)
+
+    def stop(pidfile)
+      @queue_manager.stop
+      puts "Stompserver shutting down" if $DEBUG
+      EventMachine::stop_event_loop
+      File.delete(pidfile)
     end
-    @transactions.delete(trans)
-  end
-  
-  def abort(frame, trans=nil)
-    raise "Missing transaction" unless trans
-    raise "transaction does not exist" unless @transactions.has_key?(trans)
-    @transactions.delete(trans)
-  end
-  
-  def ack(frame)
-    @@queue_manager.ack(self, frame)
-  end
-  
-  def disconnect(frame)
-    puts "Polite disconnect" if $DEBUG
-    close_connection_after_writing
-  end
 
-  def unbind
-    @@queue_manager.disconnect(self)
-    @@topic_manager.disconnect(self)
-  end
-  
-  def send_message(msg)
-    msg.command = "MESSAGE"
-    send_data(msg.to_s)
-  end
-    
-  def send_receipt(id)
-    send_frame("RECEIPT", { 'receipt-id' => id})
-  end
-  
-  def send_error(msg)
-    send_frame("ERROR",{},msg)
-  end
-  
-  def send_frame(command, headers={}, body='')
-    response = StompFrame.new(command, headers, body)
-    send_data(response.to_s)
-  end  
-end
+    def start
+      begin
+        if @opts[:group]
+          puts "Changing group to #{@opts[:group]}."
+          Process::GID.change_privilege(Etc.getgrnam(@opts[:group]).gid)
+        end
+
+        if @opts[:user]
+          puts "Changing user to #{@opts[:user]}."
+          Process::UID.change_privilege(Etc.getpwnam(@opts[:user]).uid)
+        end
+      rescue Errno::EPERM
+        puts "FAILED to change user:group #{@opts[:user]}:#{@opts[:group]}: #$!"
+        exit 1
+      end
+
+      Dir.mkdir(@opts[:working_dir]) unless File.directory?(@opts[:working_dir])
+      Dir.mkdir(@opts[:logdir]) unless File.directory?(@opts[:logdir])
+      Dir.mkdir(@opts[:etcdir]) unless File.directory?(@opts[:etcdir])
+
+      if @opts[:daemon]
+        Daemonize.daemonize(log_file=@opts[:logfile])
+        # change back to the original starting directory
+        Dir.chdir(@opts[:working_dir])
+      end
+
+      # Write pidfile
+      open(@opts[:pidfile],"w") {|f| f.write(Process.pid) }
 
-if $0 == __FILE__
-  StompServer.setup
-  EventMachine::run do
-    EventMachine.start_server "0.0.0.0", 61613, StompServer
+      if @opts[:queue] == 'dbm'
+        qstore=StompServer::DBMQueue.new(@opts[:storage])
+      elsif @opts[:queue] == 'file'
+        qstore=StompServer::FileQueue.new(@opts[:storage])
+      elsif @opts[:queue] == 'activerecord'
+        require 'stomp_server/queue/activerecord_queue'
+        qstore=StompServer::ActiveRecordQueue.new(@opts[:etcdir], @opts[:storage])
+      else
+        qstore=StompServer::MemoryQueue.new
+      end
+      @topic_manager = StompServer::TopicManager.new
+      @queue_manager = StompServer::QueueManager.new(qstore)
+      @auth_required = @opts[:auth]
+
+      if @auth_required
+        @stompauth = StompServer::StompAuth.new(@opts[:passwd])
+      end
+
+      trap("INT") { puts "INT signal received.";stop(@opts[:pidfile]) }
+    end
   end
 end
+