tkellem 0.9.0.beta3 → 0.9.0.beta4

data/lib/tkellem/models/setting.rb

@@ -1,13 +1,13 @@
 module Tkellem
 
-class Setting < Sequel::Model
+class Setting < ActiveRecord::Base
   def self.get(setting_name)
-    setting = where(:name => setting_name).first
+    setting = first(:conditions => { :name => setting_name })
     setting.try(:value)
   end
 
   def self.set(setting_name, new_value)
-    setting = where(:name => setting_name).first
+    setting = first(:conditions => { :name => setting_name })
     setting.try(:update_attributes, :value => new_value.to_s, :unchanged => false)
     setting
   end

data/lib/tkellem/models/user.rb

@@ -1,20 +1,13 @@
 module Tkellem
 
-class User < Sequel::Model
-  plugin :validation_class_methods
-
-  one_to_many :network_users, :dependent => :destroy
-  one_to_many :networks, :dependent => :destroy
+class User < ActiveRecord::Base
+  has_many :network_users, :dependent => :destroy
+  has_many :networks, :dependent => :destroy
 
   validates_presence_of :username
   validates_uniqueness_of :username
   validates_presence_of :role, :in => %w(user admin)
 
-  def before_validation
-    self.role ||= 'user'
-    super
-  end
-
   # pluggable authentication -- add your own block, which takes |username, password|
   # parameters. Return a User object if authentication succeeded, or a
   # false/nil value if auth failed. You can create the user on-the-fly if
@@ -25,7 +18,7 @@ class User < Sequel::Model
   # default database-based authentication
   # TODO: proper password hashing
   self.authentication_methods << proc do |username, password|
-    user = first(:username => username)
+    user = find_by_username(username)
     user && user.valid_password?(password) && user
   end
 
@@ -38,7 +31,7 @@ class User < Sequel::Model
   end
 
   def username=(val)
-    super(val.try(:downcase))
+    write_attribute(:username, val.try(:downcase))
   end
 
   def name
@@ -51,7 +44,7 @@ class User < Sequel::Model
   end
 
   def password=(password)
-    super(password ? OpenSSL::Digest::SHA1.hexdigest(password) : nil)
+    write_attribute(:password, password ? OpenSSL::Digest::SHA1.hexdigest(password) : nil)
   end
 
   def admin?

data/lib/tkellem/plugins/backlog.rb

@@ -15,11 +15,9 @@ module Tkellem
 # different backlog implementation. Right now, it's always loaded though.
 class Backlog
   include Tkellem::EasyLogger
-  include Celluloid
-
-  cattr_accessor :replay_pool
 
   Bouncer.add_plugin(self)
+  cattr_accessor :instances
 
   def self.get_instance(bouncer)
     bouncer.data(self)[:instance] ||= self.new(bouncer)
@@ -59,7 +57,7 @@ class Backlog
     # open stream in append-only mode
     return @streams[ctx] if @streams[ctx]
     stream = @streams[ctx] = File.open(stream_filename(ctx), 'ab')
-    stream.seek(0, ::IO::SEEK_END)
+    stream.seek(0, IO::SEEK_END)
     @starting_pos[ctx] = stream.pos
     stream
   end
@@ -118,46 +116,38 @@ class Backlog
 
   def send_backlog(conn, device)
     device.each do |ctx_name, pos|
-      filename = stream_filename(ctx_name)
-      Backlog.replay_pool.async(:replay, filename, pos, @bouncer, conn, ctx_name)
-      device[ctx_name] = get_stream(ctx_name).pos
-    end
-  end
-end
-
-class BacklogReplay
-  include Celluloid
-
-  def replay(filename, pos, bouncer, conn, ctx_name)
-    stream = File.open(filename, 'rb')
-    stream.seek(pos)
-
-    while line = stream.gets
-      timestamp, msg = parse_line(line, ctx_name)
-      next unless msg
-      privmsg = msg.args.first[0] != '#'[0]
-      if msg.prefix
-        # to this user
-        if privmsg
-          msg.args[0] = bouncer.nick
+      stream = File.open(stream_filename(ctx_name), 'rb')
+      stream.seek(pos)
+
+      while line = stream.gets
+        timestamp, msg = parse_line(line, ctx_name)
+        next unless msg
+        privmsg = msg.args.first[0] != '#'[0]
+        if msg.prefix
+          # to this user
+          if privmsg
+            msg.args[0] = @bouncer.nick
+          else
+            # do nothing, it's good to send
+          end
         else
-          # do nothing, it's good to send
-        end
-      else
-        # from this user, maybe add prefix
-        if privmsg
-          # a one-on-one chat -- every client i've seen doesn't know how to
-          # display messages from themselves here, so we fake it by just
-          # adding an arrow and pretending the other user said it. shame.
-          msg.prefix = msg.args.first
-          msg.args[0] = bouncer.nick
-          msg.args[-1] = "-> #{msg.args.last}"
-        else
-          # it's a room, we can just replay
-          msg.prefix = bouncer.nick
+          # from this user
+          if privmsg
+            # a one-on-one chat -- every client i've seen doesn't know how to
+            # display messages from themselves here, so we fake it by just
+            # adding an arrow and pretending the other user said it. shame.
+            msg.prefix = msg.args.first
+            msg.args[0] = @bouncer.nick
+            msg.args[-1] = "-> #{msg.args.last}"
+          else
+            # it's a room, we can just replay
+            msg.prefix = @bouncer.nick
+          end
         end
+        conn.send_msg(msg.with_timestamp(timestamp))
       end
-      conn.send_msg(msg.with_timestamp(timestamp))
+
+      device[ctx_name] = get_stream(ctx_name).pos
     end
   end
 
@@ -182,6 +172,4 @@ class BacklogReplay
   end
 end
 
-Backlog.replay_pool = BacklogReplay.pool(size: Celluloid.cores * 2)
-
 end

data/lib/tkellem/socket_server.rb

@@ -1,30 +1,26 @@
-require 'celluloid/io'
+require 'eventmachine'
 
 require 'tkellem/tkellem_bot'
 
 module Tkellem
 
 # listens on the unix domain socket and executes admin commands
-# TODO: rename this class
-class SocketServer
-  include Celluloid::IO
+module SocketServer
+  include EM::Protocols::LineText2
   include Tkellem::EasyLogger
-  include Tkellem::CelluloidTools::LineReader
 
   def log_name
     "admin"
   end
 
-  def initialize(socket)
-    @socket = socket
-    @delimiter = "\n"
-    async.run
+  def post_init
+    set_delimiter "\n"
   end
 
   def receive_line(line)
     trace "admin socket: #{line}"
-    TkellemBot.run_command(line, nil, nil) do |outline|
-      send_data("#{outline}\n")
+    TkellemBot.run_command(line, nil, nil) do |output|
+      send_data("#{output}\n")
     end
     send_data("\0\n")
   rescue => e
@@ -32,10 +28,6 @@ class SocketServer
     e.backtrace.each { |l| send_data("#{l}\n") }
     send_data("\0\n")
   end
-
-  def send_data(dat)
-    @socket.write(dat)
-  end
 end
 
 end

data/lib/tkellem/tkellem_bot.rb

@@ -156,7 +156,7 @@ class TkellemBot
     end
 
     def modify
-      instance = model.first(find_attributes)
+      instance = model.first(:conditions => find_attributes)
       new_record = false
       if instance
         instance.attributes = attributes
@@ -181,7 +181,7 @@ class TkellemBot
     end
 
     def remove
-      instance = model.first(find_attributes)
+      instance = model.first(:conditions => find_attributes)
       if instance
         instance.destroy
         respond "Removed #{show(instance)}"
@@ -258,7 +258,7 @@ class TkellemBot
 
       if opts['username']
         if Command.admin_user?(user)
-          user = User.where(:username => opts['username']).first
+          user = User.first(:conditions => { :username => opts['username'] })
         else
           raise Command::ArgumentError, "Only admins can change other passwords"
         end
@@ -303,7 +303,7 @@ class TkellemBot
 
     def execute
       if opts['network'].present? # only settable by admins
-        target = Network.where(:user_id => nil, :name => opts['network'].downcase).first
+        target = Network.first(:conditions => ["name = ? AND user_id IS NULL", opts['network'].downcase])
       else
         target = network_user
       end
@@ -339,7 +339,7 @@ class TkellemBot
     admin_option('public', '--public', "Create new public network. Once created, public/private status can't be modified.")
 
     def list
-      public_networks = Network.where(:user_id => nil).all
+      public_networks = Network.all(:conditions => 'user_id IS NULL')
       user_networks = user.try(:reload).try(:networks) || []
       if user_networks.present? && public_networks.present?
         r "Public networks are prefixed with [P], user-specific networks with [U]."
@@ -355,14 +355,15 @@ class TkellemBot
     end
 
     def execute
+      # TODO: this got gross
       if args.empty? && !opts['remove']
         list
         return
       end
 
       if opts['network'].present?
-        target = Network.where(:name => opts['network'].downcase, :user_id => user.try(:id)).first
-        target ||= Network.where(:user_id => nil, :name => opts['network'].downcase).first if self.class.admin_user?(user)
+        target = Network.first(:conditions => ["name = ? AND user_id = ?", opts['network'].downcase, user.try(:id)])
+        target ||= Network.first(:conditions => ["name = ? AND user_id IS NULL", opts['network'].downcase]) if self.class.admin_user?(user)
       else
         target = network_user.try(:network)
         if target && target.public? && !self.class.admin_user?(user)
@@ -378,7 +379,7 @@ class TkellemBot
         raise(Command::ArgumentError, "No network found") unless target
         raise(Command::ArgumentError, "You must explicitly specify the network to remove") unless opts['network']
         if uri
-          target.hosts.where(addr_args).first.try(:destroy)
+          target.hosts.first(:conditions => addr_args).try(:destroy)
           respond "    #{show(target)}"
         else
           target.destroy
@@ -396,9 +397,16 @@ class TkellemBot
           end
         end
 
-        Host.create(addr_args.merge(network: target))
-        respond("updated:")
-        respond "    #{show(target)}"
+        target.attributes = { :hosts_attributes => [addr_args] }
+        target.save
+        if target.errors.any?
+          respond "Error:"
+          target.errors.full_messages.each { |m| respond "    #{m}" }
+          respond "    #{show(target)}"
+        else
+          respond("updated:")
+          respond "    #{show(target)}"
+        end
       end
     end
   end

data/lib/tkellem/tkellem_server.rb

@@ -1,62 +1,47 @@
-require 'active_support/core_ext'
-require 'celluloid'
-require 'sequel'
+require 'eventmachine'
+require 'active_record'
+require 'rails/observers/activerecord/active_record'
 
-require 'tkellem/bouncer'
 require 'tkellem/bouncer_connection'
-require 'tkellem/celluloid_tools'
+require 'tkellem/bouncer'
+
+require 'tkellem/models/host'
+require 'tkellem/models/listen_address'
+require 'tkellem/models/network'
+require 'tkellem/models/network_user'
+require 'tkellem/models/setting'
+require 'tkellem/models/user'
 
 require 'tkellem/plugins/backlog'
-#require 'tkellem/plugins/push_service'
+require 'tkellem/plugins/push_service'
 
 module Tkellem
 
 class TkellemServer
-  include Celluloid
   include Tkellem::EasyLogger
 
-  attr_reader :bouncers, :options
-
-  def self.initialize_database(path)
-    Sequel.extension :migration
-    db = Sequel.connect({
-      :adapter => 'sqlite',
-      :database => path,
-    })
-    migrations_path = File.expand_path("../migrations", __FILE__)
-    Sequel::Migrator.apply(db, migrations_path)
-
-    Sequel::Model.raise_on_save_failure = true
-    # Can't load the models until we've connected to the database and migrated
-    require 'tkellem/models/host'
-    require 'tkellem/models/listen_address'
-    require 'tkellem/models/network'
-    require 'tkellem/models/network_user'
-    require 'tkellem/models/setting'
-    require 'tkellem/models/user'
-
-    db
-  end
+  attr_reader :bouncers
 
-  def initialize(options)
-    Celluloid.logger = Tkellem::EasyLogger.logger
-    @options = options
+  def initialize
     @listeners = {}
-    @bouncers = CelluloidTools::BackoffSupervisor.new_link({})
+    @bouncers = {}
     $tkellem_server = self
 
-    @db = self.class.initialize_database(db_file)
-  end
+    unless ActiveRecord::Base.connected?
+      ActiveRecord::Base.establish_connection({
+        :adapter => 'sqlite3',
+        :database => File.expand_path("~/.tkellem/tkellem.sqlite3"),
+      })
+      ActiveRecord::Migrator.migrate(File.expand_path("../migrations", __FILE__), nil)
+    end
 
-  def run
-    start_unix_server
-    ListenAddress.all { |a| listen(a) }
-    NetworkUser.all { |nu| add_bouncer(nu) }
+    ListenAddress.all.each { |a| listen(a) }
+    NetworkUser.find_each { |nu| add_bouncer(nu) }
+    Observer.forward_to << self
+  end
 
-    begin
-      loop { sleep 5 }
-    rescue Interrupt
-    end
+  def stop
+    Observer.forward_to.delete(self)
   end
 
   # callbacks for AR observer events
@@ -73,75 +58,83 @@ class TkellemServer
     case obj
     when ListenAddress
       stop_listening(obj)
-    end
-  end
-
-  def start_unix_server
-    # This file relies on the models being loaded
-    # TODO: this is gross
-    require 'tkellem/socket_server'
-    CelluloidTools::UnixListener.start(socket_file) do |socket|
-      SocketServer.new(socket)
+    when NetworkUser
+      stop_bouncer(obj)
     end
   end
 
   def listen(listen_address)
     info "Listening on #{listen_address}"
 
-    if listen_address.ssl
-      server_class = CelluloidTools::SSLListener
-    else
-      server_class = CelluloidTools::TCPListener
-    end
-
-    listener = server_class.start(listen_address.address,
-                                  listen_address.port) do |socket|
-      BouncerConnection.new(self, socket).async.run
-    end
-
-    @listeners[listen_address.id] = listener
+    @listeners[listen_address.id] = EM.start_server(listen_address.address,
+                                                    listen_address.port,
+                                                    BouncerConnection,
+                                                    self,
+                                                    listen_address.ssl)
   end
 
   def stop_listening(listen_address)
     listener = @listeners[listen_address.id]
     return unless listener
-    listener.terminate
+    EM.stop_server(listener)
     info "No longer listening on #{listen_address}"
   end
 
   def add_bouncer(network_user)
     unless network_user.user && network_user.network
-      info "Terminating orphan network user #{network_user}"
+      info "Terminating orphan network user #{network_user.inspect}"
       network_user.destroy
       return
     end
-    key = [network_user.user_id, network_user.network.name]
-    raise("bouncer already exists: #{key}") if @bouncers.registry.key?(key)
-    @bouncers.supervise_as(key, Bouncer, network_user)
+
+    key = bouncers_key(network_user)
+    raise("bouncer already exists: #{key}") if @bouncers.include?(key)
+    @bouncers[key] = Bouncer.new(bouncer)
+  end
+
+  def stop_bouncer(obj)
+    key = bouncers_key(network_user)
+    bouncer = @bouncers.delete(key)
+    if bouncer
+      bouncer.kill!
+    end
   end
 
   def find_bouncer(user, network_name)
     key = [user.id, network_name]
-    bouncer = @bouncers.registry[key]
+    bouncer = @bouncers[key]
     if !bouncer
       # find the public network with this name, and attempt to auto-add this user to it
-      network = Network.first({ :user_id => nil, :name => network_name })
+      network = Network.first(:conditions => { :user_id => nil, :name => network_name })
       if network
-        NetworkUser.create(:user => user, :network => network)
+        NetworkUser.create!(:user => user, :network => network)
         # AR callback should create the bouncer in sync
-        bouncer = @bouncers.registry[key]
+        bouncer = @bouncers[key]
       end
     end
     bouncer
   end
 
-  def socket_file
-    File.join(options[:path], 'tkellem.socket')
+  def bouncers_key(network_user)
+    [network_user.user_id, network_user.network.name]
   end
 
-  def db_file
-    File.join(options[:path], 'tkellem.sqlite3')
+  class Observer < ActiveRecord::Observer
+    observe 'Tkellem::ListenAddress', 'Tkellem::NetworkUser'
+    cattr_accessor :forward_to
+    self.forward_to = []
+
+    def after_create(obj)
+      forward_to.each { |f| f.after_create(obj) }
+    end
+
+    def after_destroy(obj)
+      forward_to.each { |f| f.after_destroy(obj) }
+    end
   end
+
+  ActiveRecord::Base.observers = Observer
+  ActiveRecord::Base.instantiate_observers
 end
 
 end

data/lib/tkellem/version.rb

@@ -1,3 +1,3 @@
 module Tkellem
-  VERSION = "0.9.0.beta3"
+  VERSION = "0.9.0.beta4"
 end

data/lib/tkellem.rb

@@ -21,7 +21,7 @@ module Tkellem
       @trace = val
     end
     def self.trace
-      @trace || @trace = true
+      @trace || @trace = false
     end
 
     def log_name
@@ -32,6 +32,15 @@ module Tkellem
       puts("TRACE: #{log_name}: #{msg}") if EasyLogger.trace
     end
 
+    def failsafe(event)
+      yield
+    rescue => e
+      # if the failsafe rescue fails, we're in a really bad state and should probably just die
+      self.error "exception while handling #{event}"
+      self.error e.to_s
+      (e.backtrace || []).each { |line| self.error line }
+    end
+
     ::Logger::Severity.constants.each do |level|
       next if level == "UNKNOWN"
       module_eval(<<-EVAL, __FILE__, __LINE__)

data/spec/bouncer_connection_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'tkellem/bouncer_connection'
+
+include Tkellem
+
+describe BouncerConnection, "connect" do
+  before do
+    @u = User.create(:username => 'speccer')
+    @u.password = 'test123'
+    @u.save
+    @tk = mock(TkellemServer)
+    @b = mock(Bouncer)
+    @bc = em(BouncerConnection).new(@tk, false)
+  end
+
+  it "should ignore blank lines" do
+    @bc.should_receive(:error!).never
+    @bc.receive_line("")
+  end
+
+  it "should connect after receiving credentials" do
+    @tk.should_receive(:find_bouncer).with(@u, 'testhost').and_return(@b)
+    @bc.receive_line("NICK speccer")
+    @bc.receive_line("PASS test123")
+    @b.should_receive(:connect_client).with(@bc)
+    @bc.receive_line("USER speccer@testhost")
+  end
+
+  it "should connect when receiving user before pass" do
+    @tk.should_receive(:find_bouncer).with(@u, 'testhost').and_return(@b)
+    @bc.receive_line("USER speccer@testhost")
+    @bc.receive_line("PASS test123")
+    @b.should_receive(:connect_client).with(@bc)
+    @bc.receive_line("NICK speccer")
+  end
+end
+