tkellem 0.7.1 → 0.8.0

data/lib/tkellem/bouncer_connection.rb

@@ -1,6 +1,7 @@
+require 'active_support/core_ext/object/blank'
+
 require 'eventmachine'
-require 'tkellem/irc_line'
-require 'tkellem/backlog'
+require 'tkellem/irc_message'
 
 module Tkellem
 
@@ -8,37 +9,36 @@ module BouncerConnection
   include EM::Protocols::LineText2
   include Tkellem::EasyLogger
 
-  def initialize(bouncer, do_ssl)
+  def initialize(tkellem_server, do_ssl)
     set_delimiter "\r\n"
 
     @ssl = do_ssl
-    @bouncer = bouncer
+    @tkellem = tkellem_server
 
-    @irc_server = nil
-    @backlog = nil
-    @nick = nil
-    @conn_name = nil
-    @name = nil
+    @state = :auth
+    @name = 'new-conn'
+    @data = {}
   end
-  attr_reader :ssl, :irc_server, :backlog, :bouncer, :nick
+  attr_reader :ssl, :bouncer, :name, :device_name
+  alias_method :log_name, :name
 
-  def connected?
-    !!irc_server
+  def nick
+    @bouncer ? @bouncer.nick : @nick
   end
 
-  def name
-    @name || "new-conn"
+  def data(key)
+    @data[key] ||= {}
   end
 
   def post_init
     if ssl
-      debug "starting TLS"
       start_tls :verify_peer => false
+    else
+      ssl_handshake_completed
     end
   end
 
   def ssl_handshake_completed
-    debug "TLS complete"
   end
 
   def error!(msg)
@@ -47,89 +47,98 @@ module BouncerConnection
     close_connection(true)
   end
 
-  def connect(conn_name, client_name, password)
-    @irc_server = bouncer.get_irc_server(conn_name.downcase)
-    unless irc_server && irc_server.connected?
-      error!("unknown connection #{conn_name}")
-      return
-    end
-
-    unless bouncer.do_auth(@nick, @password, irc_server)
-      error!("bad auth, please check your password")
-      @irc_server = @conn_name = @name = @backlog = nil
-      return
-    end
-
-    @conn_name = conn_name
-    @name = client_name
-    @backlog = irc_server.bouncer_connect(self)
-    unless backlog
-      error!("unknown client #{client_name}")
-      @irc_server = @conn_name = @name = nil
-      return
-    end
-
+  def connect_to_irc_server
+    @bouncer = @tkellem.find_bouncer(@user, @conn_name)
+    return error!("Unknown connection: #{@conn_name}") unless @bouncer
+    @state = :connected
     info "connected"
-
-    irc_server.send_welcome(self)
-    backlog.send_backlog(self)
-    irc_server.rooms.each { |room| simulate_join(room) }
+    @bouncer.connect_client(self)
   end
 
-  def tkellem(msg)
-    case msg.args.first
-    when /nothing_yet/i
-    else
-      send_msg(":tkellem!tkellem@tkellem PRIVMSG #{nick} :Unknown tkellem command #{msg.args.first}")
+  def msg_tkellem(msg)
+    TkellemBot.run_command(msg.args.join(' '), @user) do |response|
+      say_as_tkellem(response)
     end
   end
 
+  def say_as_tkellem(message)
+    send_msg(":-tkellem!~tkellem@tkellem PRIVMSG #{nick} :#{message}")
+  end
+
   def receive_line(line)
     trace "from client: #{line}"
-    msg = IrcLine.parse(line)
-    case msg.command
-    when /tkellem/i
-      tkellem(msg)
-    when /pass/i
-      @password = msg.args.first
-    when /user/i
-      @conn_name, @client_name = msg.args.last.strip.split(' ')
-    when /nick/i
-      if connected?
-        irc_server.change_nick(msg.last)
-      else
-        @nick = msg.last
-        connect(@conn_name, @client_name, @password)
+    msg = IrcMessage.parse(line)
+
+    command = msg.command
+    if @user && command == 'PRIVMSG' && msg.args.first == '-tkellem'
+      msg_tkellem(IrcMessage.new(nil, 'TKELLEM', [msg.args.last]))
+    elsif command == 'TKELLEM'
+      msg_tkellem(msg)
+    elsif command == 'CAP'
+      # TODO: full support for CAP -- this just gets mobile colloquy connecting
+      if msg.args.first =~ /req/i
+        send_msg("CAP NAK")
       end
-    when /quit/i
-      # DENIED
+    elsif command == 'PASS'
+      unless @password
+        @password = msg.args.first
+      end
+    elsif command == 'NICK' && @state == :auth
+      @nick = msg.args.first
+    elsif command == 'QUIT'
       close_connection
-    when /ping/i
-      send_msg(":tkellem PONG tkellem :#{msg.last}")
+    elsif command == 'USER'
+      msg_user(msg)
+    elsif @state == :auth
+      error!("Protocol error. You must authenticate first.")
+    elsif @state == :connected
+      @bouncer.client_msg(self, msg)
     else
-      if !connected?
-        close_connection
+      say_as_tkellem("You must connect to an irc network to do that.")
+    end
+
+  rescue => e
+    error "Error handling message: {#{msg}} #{e}"
+    e.backtrace.each { |l| error l }
+    begin
+      error! "Internal Tkellem error."
+    rescue
+    end
+  end
+
+  def msg_user(msg)
+    unless @user
+      @username, rest = msg.args.first.strip.split('@', 2).map { |a| a.downcase }
+      @name = @username
+      @user = User.authenticate(@username, @password)
+      return error!("Unknown username: #{@username} or bad password.") unless @user
+
+      if rest && !rest.empty?
+        @conn_name, @device_name = rest.split(':', 2)
+        # 'default' or missing device_name to use the default backlog
+        # pass a device_name to have device-independent backlogs
+        @device_name = @device_name.presence || 'default'
+        @name = "#{@username}-#{@conn_name}"
+        @name += "-#{@device_name}" if @device_name
+        connect_to_irc_server
       else
-        # pay it forward
-        irc_server.send_msg(msg)
+        @name = "#{@username}-console"
+        connect_to_tkellem_console
       end
     end
   end
 
+  def connect_to_tkellem_console
+    send_msg(":tkellem 001 #{nick} :Welcome to the Tkellem admin console")
+    send_msg(":tkellem 376 #{nick} :End")
+    @state = :console
+  end
+
   def simulate_join(room)
-    send_msg(":#{irc_server.nick}!#{name}@tkellem JOIN #{room}")
+    send_msg(":#{nick}!#{name}@tkellem JOIN #{room}")
     # TODO: intercept the NAMES response so that only this bouncer gets it
     # Otherwise other clients might show an "in this room" line.
-    irc_server.send_msg("NAMES #{room}\r\n")
-  end
-
-  def transient_response(msg)
-    send_msg(msg)
-    if msg.command == "366"
-      # finished joining this room, let's backlog it
-      debug "got final NAMES for #{msg.args[1]}, sending backlog"
-      backlog.send_backlog(self, msg.args[1])
-    end
+    @bouncer.send_msg("NAMES #{room}\r\n")
   end
 
   def send_msg(msg)
@@ -137,12 +146,8 @@ module BouncerConnection
     send_data("#{msg}\r\n")
   end
 
-  def log_name
-    "#{@conn_name}-#{name}"
-  end
-
   def unbind
-    irc_server.bouncer_disconnect(self) if connected?
+    @bouncer.disconnect_client(self) if @bouncer
   end
 end
 

data/lib/tkellem/daemon.rb

@@ -0,0 +1,155 @@
+require 'fileutils'
+require 'optparse'
+
+require 'tkellem'
+require 'tkellem/socket_server'
+
+class Tkellem::Daemon
+  attr_reader :options
+
+  def initialize(args)
+    @args = args
+    @options = {
+      :path => File.expand_path("~/.tkellem/"),
+    }
+  end
+
+  def run
+    OptionParser.new do |opts|
+      opts.banner = "Usage #{$0} <command> <options>"
+      opts.separator %{\nWhere <command> is one of:
+  start      start the jobs daemon
+  stop       stop the jobs daemon
+  run        start and run in the foreground
+  restart    stop and then start the jobs daemon
+  status     show daemon status
+  admin      run admin commands as if connected to the tkellem console
+}
+
+      opts.separator "\n<options>"
+      opts.on("-p", "--path", "Use alternate folder for tkellem data (default #{options[:path]})") { |p| options[:path] = p }
+      opts.on_tail("-h", "--help", "Show this message") { puts opts; exit }
+    end.parse!(@args)
+
+    FileUtils.mkdir_p(path)
+    File.chmod(0700, path)
+    command = @args.shift
+    case command
+    when 'start'
+      daemonize
+      start
+    when 'stop'
+      stop
+    when 'run'
+      start
+    when 'status'
+      exit(status ? 0 : 1)
+    when 'restart'
+      stop if status(false)
+      while status(false)
+        print "."
+        sleep(0.5)
+      end
+      daemonize
+      start
+    when 'admin'
+      admin
+    else
+      raise("Unknown command: #{command.inspect}")
+    end
+  end
+
+  protected
+
+  def admin
+    require 'socket'
+    socket = UNIXSocket.new(socket_file)
+    line = @args.join(' ').strip
+    if line.empty?
+      require 'readline'
+      while line = Readline.readline('> ', true)
+        admin_command(line, socket)
+      end
+    else
+      admin_command(line, socket)
+    end
+  end
+
+  def admin_command(line, socket)
+    socket.puts(line)
+    loop do
+     line = socket.readline("\n").chomp
+     puts line
+     if line == "\0"
+       break
+     end
+    end
+  end
+
+  def start
+    trap("INT") { EM.stop }
+    EM.run do
+      @admin = EM.start_unix_domain_server(socket_file, Tkellem::SocketServer)
+      Tkellem::TkellemServer.new
+    end
+  ensure
+    remove_files
+  end
+
+  def daemonize
+    puts "Daemonizing..."
+    exit if fork
+    Process.setsid
+    exit if fork
+    @daemon = true
+    File.open(pid_file, 'wb') { |f| f.write(Process.pid.to_s) }
+
+    # TODO: set up logging
+    STDIN.reopen("/dev/null")
+    STDOUT.reopen("/dev/null")
+    STDERR.reopen(STDOUT)
+    # STDOUT.sync = STDERR.sync = true
+  end
+
+  def stop
+    pid = File.read(pid_file) if File.file?(pid_file)
+    if pid.to_i > 0
+      puts "Stopping tkellem #{pid}..."
+      Process.kill('INT', pid.to_i)
+    else
+      status
+    end
+  end
+
+  def status(print = true)
+    pid = File.read(pid_file) if File.file?(pid_file)
+    if pid
+      puts "tkellem running, pid: #{pid}" if print
+    else
+      puts "tkellem not running" if print
+    end
+    pid.to_i > 0 ? pid.to_i : nil
+  end
+
+  def remove_files
+    FileUtils.rm(socket_file)
+    return unless @daemon
+    pid = File.read(pid_file) if File.file?(pid_file)
+    if pid.to_i == Process.pid
+      FileUtils.rm(pid_file)
+    end
+  end
+
+  def path
+    options[:path]
+  end
+
+  def pid_file
+    File.join(path, 'tkellem.pid')
+  end
+
+  def socket_file
+    File.join(path, 'tkellem.socket')
+  end
+
+end

data/lib/tkellem/irc_message.rb

@@ -0,0 +1,58 @@
+module Tkellem
+
+class IrcMessage < Struct.new(:prefix, :command, :args)
+  RE = %r{(:[^ ]+ )?([^ ]*)(.*)}i
+
+  def self.parse(line)
+    md = RE.match(line) or raise("invalid input: #{line.inspect}")
+
+    prefix = md[1] && md[1][1..-1].strip
+    command = md[2].upcase
+    args = md[3]
+
+    args.strip!
+    idx = args.index(":")
+    if idx && (idx == 0 || args[idx-1] == " "[0])
+      args = args[0...idx].split(' ') + [args[idx+1..-1]]
+    else
+      args = args.split(' ')
+    end
+
+    self.new(prefix, command, args)
+  end
+
+  def command?(cmd)
+    @command.downcase == cmd.downcase
+  end
+
+  def replay
+    line = []
+    line << ":#{prefix}" unless prefix.nil?
+    line << command
+    ext_arg = args.last if args.last && args.last.match(%r{\s})
+    line += ext_arg ? args[0...-1] : args
+    line << ":#{ext_arg}" unless ext_arg.nil?
+    line.join ' '
+  end
+  alias_method :to_s, :replay
+
+  def target_user
+    if prefix && md = %r{^([^!]+)}.match(prefix)
+      md[1]
+    else
+      nil
+    end
+  end
+
+  def with_timestamp(timestamp)
+    args = self.args
+    if args && args[-1]
+      args = args.dup
+      args[-1] = "#{timestamp.strftime("%H:%M:%S")}> #{args[-1]}"
+    end
+    IrcMessage.new(prefix, command, args)
+  end
+
+end
+
+end

data/lib/tkellem/irc_server.rb

@@ -1,47 +1,23 @@
 require 'set'
 require 'eventmachine'
-require 'tkellem/irc_line'
+require 'tkellem/irc_message'
 require 'tkellem/bouncer_connection'
-require 'tkellem/backlog'
 
 module Tkellem
 
-module IrcServer
+module IrcServerConnection
   include EM::Protocols::LineText2
   include Tkellem::EasyLogger
 
-  def initialize(bouncer, name, do_ssl, nick)
+  def initialize(bouncer, do_ssl)
     set_delimiter "\r\n"
-
     @bouncer = bouncer
-    @name = name
     @ssl = do_ssl
-    @nick = nick
-
-    @max_backlog = nil
-    @connected = false
-    @welcomes = []
-    @rooms = Set.new
-    @backlogs = {}
-    @active_conns = []
-    @joined_rooms = false
-    @pending_rooms = []
-  end
-  attr_reader :name, :backlogs, :welcomes, :rooms, :nick, :active_conns
-  alias_method :log_name, :name
-
-  def connected?
-    @connected
-  end
-
-  def set_max_backlog(max_backlog)
-    @max_backlog = max_backlog
-    backlogs.each { |name, backlog| backlog.max_backlog = max_backlog }
   end
 
   def post_init
     if @ssl
-      debug "starting TLS"
+      @bouncer.debug "starting TLS"
       # TODO: support strict cert checks
       start_tls :verify_peer => false
     else
@@ -50,106 +26,17 @@ module IrcServer
   end
 
   def ssl_handshake_completed
-    # TODO: support sending a real username, realname, etc
-    send_msg("USER #{nick} localhost blah :#{nick}")
-    change_nick(nick, true)
+    EM.next_tick { @bouncer.connection_established }
   end
 
   def receive_line(line)
     trace "from server: #{line}"
-    msg = IrcLine.parse(line)
-
-    case msg.command
-    when /0\d\d/, /2[56]\d/, /37[256]/
-      welcomes << msg
-      got_welcome if msg.command == "376" # end of MOTD
-    when /join/i
-      debug "#{msg.target_user} joined #{msg.last}"
-      rooms << msg.last if msg.target_user == nick
-    when /part/i
-      debug "#{msg.target_user} left #{msg.last}"
-      rooms.delete(msg.last) if msg.target_user == nick
-    when /ping/i
-      send_msg("PONG #{nick}!tkellem #{msg.args.first}")
-    when /pong/i
-      # swallow it, we handle ping-pong from clients separately, in
-      # BouncerConnection
-    else
-    end
-
-    backlogs.each { |name, backlog| backlog.handle_message(msg) }
-  end
-
-  def got_welcome
-    return if @joined_rooms
-    @joined_rooms = true
-    @pending_rooms.each do |room|
-      join_room(room)
-    end
-    @pending_rooms.clear
-
-    # We're all initialized, allow connections
-    @connected = true
-  end
-
-  def change_nick(new_nick, force = false)
-    return if !force && new_nick == @nick
-    @nick = new_nick
-    send_msg("NICK #{new_nick}")
-  end
-
-  def join_room(room_name)
-    if @joined_rooms
-      send_msg("JOIN #{room_name}")
-    else
-      @pending_rooms << room_name
-    end
-  end
-
-  def add_client(name)
-    return if backlogs[name]
-    backlog = Backlog.new(name, @max_backlog)
-    backlogs[name] = backlog
-  end
-
-  def remove_client(name)
-    backlog = backlogs.delete(name)
-    if backlog
-      backlog.active_conns.each do |conn|
-        conn.error!("client removed")
-      end
-    end
-  end
-
-  def send_msg(msg)
-    trace "to server: #{msg}"
-    send_data("#{msg}\r\n")
-  end
-
-  def send_welcome(bouncer_conn)
-    welcomes.each { |msg| bouncer_conn.send_msg(msg) }
+    msg = IrcMessage.parse(line)
+    @bouncer.server_msg(msg)
   end
 
   def unbind
-    debug "OMG we got disconnected."
-    # TODO: reconnect if desired. but not if this server was explicitly shut
-    # down or removed.
-    backlogs.keys.each { |name| remove_client(name) }
-  end
-
-  def bouncer_connect(bouncer_conn)
-    return nil unless backlogs[bouncer_conn.name]
-
-    active_conns << bouncer_conn
-    backlogs[bouncer_conn.name].add_conn(bouncer_conn)
-    backlogs[bouncer_conn.name]
-  end
-
-  def bouncer_disconnect(bouncer_conn)
-    return nil unless backlogs[bouncer_conn.name]
-
-    backlogs[bouncer_conn.name].remove_conn(bouncer_conn)
-    active_conns.delete(bouncer_conn)
+    @bouncer.disconnected!
   end
 end
 

data/lib/tkellem/migrations/001_init_db.rb

@@ -0,0 +1,33 @@
+class InitDb < ActiveRecord::Migration
+  def self.up
+    create_table 'listen_addresses' do |t|
+      t.string  'address', :null => false
+      t.integer 'port', :null => false
+      t.boolean 'ssl', :null => false, :default => false
+    end
+
+    create_table 'users' do |t|
+      t.string 'username', :null => false
+      t.string 'password'
+      t.string 'role', :null => false, :default => 'user'
+    end
+
+    create_table 'networks' do |t|
+      t.belongs_to 'user'
+      t.string 'name', :null => false
+    end
+
+    create_table 'hosts' do |t|
+      t.belongs_to 'network'
+      t.string  'address', :null => false
+      t.integer 'port', :null => false
+      t.boolean 'ssl', :null => false, :default => false
+    end
+
+    create_table 'network_users' do |t|
+      t.belongs_to 'user'
+      t.belongs_to 'network'
+      t.string 'nick'
+    end
+  end
+end

data/lib/tkellem/models/host.rb

@@ -0,0 +1,11 @@
+module Tkellem
+
+class Host < ActiveRecord::Base
+  belongs_to :network
+
+  def to_s
+    "#{ssl ? 'ircs' : 'irc'}://#{address}:#{port}"
+  end
+end
+
+end

data/lib/tkellem/models/listen_address.rb

@@ -0,0 +1,12 @@
+module Tkellem
+
+class ListenAddress < ActiveRecord::Base
+  validates_uniqueness_of :port, :scope => [:address]
+  validates_presence_of :address, :port
+
+  def to_s
+    "#{ssl ? 'ircs' : 'irc'}://#{address}:#{port}"
+  end
+end
+
+end

data/lib/tkellem/models/network.rb

@@ -0,0 +1,15 @@
+module Tkellem
+
+class Network < ActiveRecord::Base
+  has_many :hosts, :dependent => :destroy
+  has_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
+
+  def public?
+    !user
+  end
+end
+
+end

data/lib/tkellem/models/network_user.rb

@@ -0,0 +1,12 @@
+module Tkellem
+
+class NetworkUser < ActiveRecord::Base
+  belongs_to :network
+  belongs_to :user
+
+  def nick
+    read_attribute(:nick) || user.name
+  end
+end
+
+end