tkellem 0.8.11 → 0.9.0.beta1

data/lib/tkellem/models/network.rb

@@ -1,20 +1,24 @@
 module Tkellem
 
-class Network < ActiveRecord::Base
-  has_many :hosts, :dependent => :destroy
-  accepts_nested_attributes_for :hosts
+class Network < Sequel::Model
+  plugin :nested_attributes
+  plugin :validation_class_methods
+  plugin :serialization
 
-  has_many :network_users, :dependent => :destroy
+  one_to_many :hosts, :dependent => :destroy
+  nested_attributes :hosts
+
+  one_to_many :network_users, :dependent => :destroy
   # networks either belong to a specific user, or they are public and any user
   # can join them.
-  belongs_to :user
+  many_to_one :user
 
   validates_uniqueness_of :name, :scope => :user_id
 
-  serialize :at_connect, Array
+  serialize_attributes :yaml, :at_connect
 
   def at_connect
-    read_attribute(:at_connect) || []
+    super || []
   end
 
   def public?

data/lib/tkellem/models/network_user.rb

@@ -1,17 +1,33 @@
 module Tkellem
 
-class NetworkUser < ActiveRecord::Base
-  belongs_to :network
-  belongs_to :user
+class NetworkUser < Sequel::Model
+  plugin :serialization
 
-  serialize :at_connect, Array
+  many_to_one :network
+  many_to_one :user
+
+  serialize_attributes :yaml, :at_connect
+
+  def at_connect
+    super || []
+  end
 
   def nick
-    read_attribute(:nick) || user.name
+    super || user.name
   end
 
   def combined_at_connect
-    network.at_connect + (at_connect || [])
+    network.at_connect + at_connect
+  end
+
+  def after_create
+    super
+    $tkellem_server.try(:after_create, self)
+  end
+
+  def after_destroy
+    super
+    $tkellem_server.try(:after_destroy, self)
   end
 end
 

data/lib/tkellem/models/setting.rb

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

data/lib/tkellem/models/user.rb

@@ -1,13 +1,20 @@
 module Tkellem
 
-class User < ActiveRecord::Base
-  has_many :network_users, :dependent => :destroy
-  has_many :networks, :dependent => :destroy
+class User < Sequel::Model
+  plugin :validation_class_methods
+
+  one_to_many :network_users, :dependent => :destroy
+  one_to_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
@@ -18,7 +25,7 @@ class User < ActiveRecord::Base
   # default database-based authentication
   # TODO: proper password hashing
   self.authentication_methods << proc do |username, password|
-    user = find_by_username(username)
+    user = first(:username => username)
     user && user.valid_password?(password) && user
   end
 
@@ -31,7 +38,7 @@ class User < ActiveRecord::Base
   end
 
   def username=(val)
-    write_attribute(:username, val.try(:downcase))
+    super(val.try(:downcase))
   end
 
   def name
@@ -44,7 +51,7 @@ class User < ActiveRecord::Base
   end
 
   def password=(password)
-    write_attribute(:password, password ? OpenSSL::Digest::SHA1.hexdigest(password) : nil)
+    super(password ? OpenSSL::Digest::SHA1.hexdigest(password) : nil)
   end
 
   def admin?

data/lib/tkellem/plugins/backlog.rb

@@ -15,9 +15,11 @@ 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)
@@ -57,7 +59,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
@@ -98,7 +100,7 @@ class Backlog
         ctx = msg.prefix.split(/[!~@]/, 2).first
       end
       stream = get_stream(ctx)
-      stream.puts(Time.now.strftime("%d-%m-%Y %H:%M:%S < #{'* ' if msg.action?}#{msg.prefix}: #{msg.args.last}"))
+      stream.puts(Time.now.strftime("%d-%m-%Y %H:%M:%S") + " < #{'* ' if msg.action?}#{msg.prefix}: #{msg.args.last}")
       update_pos(ctx, stream.pos)
     end
   end
@@ -109,39 +111,53 @@ class Backlog
       return if msg.ctcp? && !msg.action?
       ctx = msg.args.first
       stream = get_stream(ctx)
-      stream.puts(Time.now.strftime("%d-%m-%Y %H:%M:%S > #{'* ' if msg.action?}#{msg.args.last}"))
+      stream.puts(Time.now.strftime("%d-%m-%Y %H:%M:%S") + " > #{'* ' if msg.action?}#{msg.args.last}")
       update_pos(ctx, stream.pos)
     end
   end
 
   def send_backlog(conn, device)
     device.each do |ctx_name, pos|
-      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
-        if msg.prefix
-          # to user
+      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
         else
-          # from user, add prefix
-          if msg.args.first[0] == '#'[0]
-            # it's a room, we can just replay
-            msg.prefix = @bouncer.nick
-          else
-            # 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}"
-          end
+          # 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
         end
-        conn.send_msg(msg.with_timestamp(timestamp))
       end
-
-      device[ctx_name] = get_stream(ctx_name).pos
+      conn.send_msg(msg.with_timestamp(timestamp))
     end
   end
 
@@ -166,4 +182,6 @@ class Backlog
   end
 end
 
+Backlog.replay_pool = BacklogReplay.pool(size: Celluloid.cores * 2)
+
 end

data/lib/tkellem/socket_server.rb

@@ -1,26 +1,30 @@
-require 'eventmachine'
+require 'celluloid/io'
 
 require 'tkellem/tkellem_bot'
 
 module Tkellem
 
 # listens on the unix domain socket and executes admin commands
-module SocketServer
-  include EM::Protocols::LineText2
+# TODO: rename this class
+class SocketServer
+  include Celluloid::IO
   include Tkellem::EasyLogger
+  include Tkellem::CelluloidTools::LineReader
 
   def log_name
     "admin"
   end
 
-  def post_init
-    set_delimiter "\n"
+  def initialize(socket)
+    @socket = socket
+    @delimiter = "\n"
+    run!
   end
 
   def receive_line(line)
     trace "admin socket: #{line}"
-    TkellemBot.run_command(line, nil, nil) do |line|
-      send_data("#{line}\n")
+    TkellemBot.run_command(line, nil, nil) do |outline|
+      send_data("#{outline}\n")
     end
     send_data("\0\n")
   rescue => e
@@ -28,6 +32,10 @@ module 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(:conditions => find_attributes)
+      instance = model.first(find_attributes)
       new_record = false
       if instance
         instance.attributes = attributes
@@ -181,7 +181,7 @@ class TkellemBot
     end
 
     def remove
-      instance = model.first(:conditions => find_attributes)
+      instance = model.first(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.first(:conditions => { :username => opts['username'] })
+          user = User.where(:username => opts['username']).first
         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.first(:conditions => ["name = ? AND user_id IS NULL", opts['network'].downcase])
+        target = Network.where(:user_id => nil, :name => opts['network'].downcase).first
       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.all(:conditions => 'user_id IS NULL')
+      public_networks = Network.where(:user_id => nil).all
       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,15 +355,14 @@ class TkellemBot
     end
 
     def execute
-      # TODO: this got gross
       if args.empty? && !opts['remove']
         list
         return
       end
 
       if opts['network'].present?
-        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)
+        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)
       else
         target = network_user.try(:network)
         if target && target.public? && !self.class.admin_user?(user)
@@ -379,7 +378,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.first(:conditions => addr_args).try(:destroy)
+          target.hosts.where(addr_args).first.try(:destroy)
           respond "    #{show(target)}"
         else
           target.destroy
@@ -397,16 +396,9 @@ class TkellemBot
           end
         end
 
-        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
+        Host.create(addr_args.merge(network: target))
+        respond("updated:")
+        respond "    #{show(target)}"
       end
     end
   end

data/lib/tkellem/tkellem_server.rb

@@ -1,46 +1,62 @@
-require 'eventmachine'
-require 'active_record'
+require 'active_support/core_ext'
+require 'celluloid'
+require 'sequel'
 
-require 'tkellem/bouncer_connection'
 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/bouncer_connection'
+require 'tkellem/celluloid_tools'
 
 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
+  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
 
-  def initialize
+  def initialize(options)
+    Celluloid.logger = Tkellem::EasyLogger.logger
+    @options = options
     @listeners = {}
-    @bouncers = {}
+    @bouncers = CelluloidTools::BackoffSupervisor.new_link({})
     $tkellem_server = self
 
-    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
-
-    ListenAddress.all.each { |a| listen(a) }
-    NetworkUser.find_each { |nu| add_bouncer(Bouncer.new(nu)) }
-    Observer.forward_to << self
+    @db = self.class.initialize_database(db_file)
   end
 
-  def stop
-    Observer.forward_to.delete(self)
+  def run
+    start_unix_server
+    ListenAddress.all { |a| listen(a) }
+    NetworkUser.all { |nu| add_bouncer(nu) }
+
+    begin
+      loop { sleep 5 }
+    rescue Interrupt
+    end
   end
 
   # callbacks for AR observer events
@@ -49,7 +65,7 @@ class TkellemServer
     when ListenAddress
       listen(obj)
     when NetworkUser
-      add_bouncer(Bouncer.new(obj))
+      add_bouncer(obj)
     end
   end
 
@@ -57,68 +73,75 @@ class TkellemServer
     case obj
     when ListenAddress
       stop_listening(obj)
-    # TODO: remove bouncer on NetworkUser.destroy
     end
   end
 
-  def listen(listen_address)
-    address = listen_address.address
-    port = listen_address.port
-    ssl = listen_address.ssl
+  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)
+    end
+  end
 
+  def listen(listen_address)
     info "Listening on #{listen_address}"
 
-    @listeners[listen_address.id] = EM.start_server(listen_address.address,
-                                                    listen_address.port,
-                                                    BouncerConnection,
-                                                    self,
-                                                    listen_address.ssl)
+    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
   end
 
   def stop_listening(listen_address)
     listener = @listeners[listen_address.id]
     return unless listener
-    EM.stop_server(listener)
+    listener.terminate
     info "No longer listening on #{listen_address}"
   end
 
-  def add_bouncer(bouncer)
-    key = [bouncer.user.id, bouncer.network.name]
-    raise("bouncer already exists: #{key}") if @bouncers.include?(key)
-    @bouncers[key] = bouncer
+  def add_bouncer(network_user)
+    unless network_user.user && network_user.network
+      info "Terminating orphan network user #{network_user}"
+      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)
   end
 
   def find_bouncer(user, network_name)
     key = [user.id, network_name]
-    bouncer = @bouncers[key]
+    bouncer = @bouncers.registry[key]
     if !bouncer
       # find the public network with this name, and attempt to auto-add this user to it
-      network = Network.first(:conditions => { :user_id => nil, :name => network_name })
+      network = Network.first({ :user_id => nil, :name => network_name })
       if network
-        nu = NetworkUser.create!(:user => user, :network => network)
+        NetworkUser.create(:user => user, :network => network)
         # AR callback should create the bouncer in sync
-        bouncer = @bouncers[key]
+        bouncer = @bouncers.registry[key]
       end
     end
     bouncer
   end
 
-  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
+  def socket_file
+    File.join(options[:path], 'tkellem.socket')
   end
 
-  ActiveRecord::Base.observers = Observer
-  ActiveRecord::Base.instantiate_observers
+  def db_file
+    File.join(options[:path], 'tkellem.sqlite3')
+  end
 end
 
 end

data/lib/tkellem/version.rb

@@ -1,3 +1,3 @@
 module Tkellem
-  VERSION = "0.8.11"
+  VERSION = "0.9.0.beta1"
 end

data/lib/tkellem.rb

@@ -21,7 +21,7 @@ module Tkellem
       @trace = val
     end
     def self.trace
-      @trace || @trace = false
+      @trace || @trace = true
     end
 
     def log_name
@@ -32,15 +32,6 @@ 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/spec_helper.rb

@@ -5,30 +5,17 @@ require 'tkellem'
 require 'rspec'
 
 Tkellem::EasyLogger.logger = Logger.new("test.log")
-ActiveRecord::Base.logger = Tkellem::EasyLogger.logger
 
-ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
-ActiveRecord::Migration.verbose = false
-ActiveRecord::Migrator.migrate(File.expand_path("../../lib/tkellem/migrations", __FILE__), nil)
+TestDB = Tkellem::TkellemServer.initialize_database(':memory:')
 
 RSpec.configure do |config|
-  config.before(:each) do
-    ActiveRecord::Base.connection.increment_open_transactions
-    ActiveRecord::Base.connection.begin_db_transaction
-  end
-
-  config.after(:each) do
-    ActiveRecord::Base.connection.rollback_db_transaction
-    ActiveRecord::Base.connection.decrement_open_transactions
+  config.around(:each) do |block|
+    TestDB.transaction(:rollback => :always) do
+      block.run()
+    end
   end
 
   def m(line)
     IrcMessage.parse(line)
   end
-
-  def em(mod)
-    c = Class.new
-    c.send(:include, mod)
-    c
-  end
 end