tkellem 0.7.1 → 0.8.0

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+coverage/*
+doc/*
+.yardoc/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in ruby-protocol-buffers.gemspec
+gemspec

data/README.md

@@ -4,14 +4,36 @@ tkellem is an IRC bouncer, a proxy that keeps you permanently logged on to an
 IRC server and stores all messages so that when your client next connects, you
 can see the backlog of what happened while you were gone.
 
-tkellem supports multiple device-independent backlogs, and connecting to
-multiple IRC servers all from the same process.
+tkellem supports multiple users, multiple device-independent backlogs
+per-user, and connecting to multiple IRC servers all from the same
+process.
 
 ## IMPORTANT
 
-This is a very, very early version. Only the basic functionality is implemented.
-You probably don't want this yet.
+This is still a pretty early alpha. Expect bugs and missing
+functionality.
 
-## Usage
+## Getting Started
 
-    bin/tkellem examples/config.yml
+This will have to do as a quickstart guide, for now:
+
+    $ git clone git://github.com/codekitchen/tkellem.git
+    $ cd tkellem
+    $ bundle install
+    $ bundle exec bin/tkellem start
+    $ bundle exec bin/tkellem admin
+    > help
+    > listen ircs://0.0.0.0:8765
+    > user --add <my-name> --admin
+    > password --user <my-name> <my-new-password>
+    > network --add --public freenode ircs://irc.freenode.org:7000
+
+Then connect to tkellem with an irc client:
+
+    server: localhost
+    port: 8765
+    ssl: yes
+
+    nickname: <my-name>
+    login: <my-name>@freenode
+    server password: <my-new-password>

data/Rakefile

@@ -1,12 +1,21 @@
-require 'rubygems'
-require 'rake'
-require 'rspec'
-require 'rspec/core/rake_task'
+require 'bundler'
+Bundler::GemHelper.install_tasks
 
 task :default => :spec
 
+require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.pattern = 'spec/spec_helper.rb'
+  spec.pattern = 'spec/*_spec.rb'
+end
+RSpec::Core::RakeTask.new(:rcov) do |t|
+  t.rcov = true
+  t.rcov_opts = ["--exclude", "spec,gems/,rubygems/"]
+end
+
+require 'yard'
+YARD::Rake::YardocTask.new(:doc) do |t|
+  version = Tkellem::VERSION
+  t.options = ["--title", "tkellem #{version}", "--files", "LICENSE,README.md"]
 end
 
 begin

data/bin/tkellem

@@ -1,110 +1,5 @@
 #!/usr/bin/env ruby
 
-begin
-  require 'rubygems'
-rescue LoadError
-end
-require 'yaml'
-require 'optparse'
+require 'tkellem/daemon'
 
-opts = OptionParser.new
-opts.banner = <<BANNER
-Usage: #{opts.program_name} PATH_TO_CONFIG
-
-Start a tkellem instance using the specified configuration file (or ~/.tkellem/config.yml if none given)
-BANNER
-
-opts.on_tail("-h", "--help") { puts opts; exit }
-
-rest = opts.parse(ARGV)
-config_filename = rest.first || File.expand_path(ENV["HOME"]+'/.tkellem/config.yml')
-
-config = YAML.load_file(config_filename)
-
-$LOAD_PATH.push(File.expand_path(File.dirname(__FILE__)+'/../lib'))
-require 'tkellem'
-
-EM.run do
-  bouncer =
-    Tkellem::Bouncer.new(config['listen'] || '0.0.0.0',
-                         config['port'] || 10001,
-                         config['ssl'])
-
-  bouncer.max_backlog = config['max_backlog'].to_i
-
-  bouncer.on_authenticate do |username, password, irc_server|
-    server_config = config['connections'][irc_server.name]
-    if server_config && password_sha1 = server_config['password_sha1']
-      require 'openssl'
-      password_sha1 == OpenSSL::Digest::SHA1.hexdigest(password)
-    else
-      true
-    end
-  end
-
-  def add_irc_server(bouncer, name, conn)
-    server = bouncer.add_irc_server(name,
-                                    conn['host'], conn['port'], conn['ssl'],
-                                    conn['nick'])
-
-    (conn['rooms'] || []).each { |room| server.join_room(room['name']) }
-    conn['clients'].each { |client| server.add_client(client['name']) }
-  end
-
-  config['connections'].each do |name, conn|
-    Tkellem::EasyLogger.logger.info("adding new connection #{name}")
-    add_irc_server(bouncer, name, conn)
-  end
-
-  Signal.trap('HUP') do
-    Tkellem::EasyLogger.logger.warn("got HUP, reloading #{config_filename}")
-    new_config = YAML.load_file(config_filename)
-
-    bouncer.max_backlog = new_config['max_backlog'].to_i
-
-    # find changed connections
-    to_delete = config['connections'].keys
-
-    new_config['connections'].each do |name, new_conn|
-      to_delete.delete(name)
-      conn = config['connections'][name]
-      if !conn
-        Tkellem::EasyLogger.logger.info("adding new connection #{name}")
-        add_irc_server(bouncer, name, new_conn)
-      else
-        if new_conn['host'] != conn['host'] || new_conn['port'] != conn['port'] || new_conn['ssl'] != conn['ssl']
-          Tkellem::EasyLogger.logger.info("server settings changed for #{name}, dropping clients and reconnecting")
-          bouncer.remove_irc_server(name)
-          add_irc_server(bouncer, name, new_conn)
-        elsif conn['clients'] != new_conn['clients']
-          irc_server = bouncer.get_irc_server(name)
-
-          # we don't have to reconnect, but maybe clients changed. we ignore
-          # changes to nick and rooms on HUP, since those are dynamic once tkellem
-          # connects.  password change will be caught on the next client
-          # connect.
-          clients_to_delete = conn['clients'].map { |c| c['name'] }
-          new_conn['clients'].each do |new_client|
-            clients_to_delete.delete(new_client['name'])
-            # add -- if already exists, this is a no-op. this may change in the
-            # future though...
-            Tkellem::EasyLogger.logger.info("adding client #{new_client['name']} to server #{name}")
-            irc_server.add_client(new_client['name'])
-          end
-          clients_to_delete.each do |client_name|
-            Tkellem::EasyLogger.logger.info("removing client #{client_name} from server #{name}")
-            irc_server.remove_client(client_name) if irc_server
-          end
-        end
-      end
-    end
-
-    to_delete.each do |name|
-      Tkellem::EasyLogger.logger.info("deleting connection #{name}")
-      bouncer.remove_irc_server(name)
-    end
-
-    config = new_config
-  end
-
-end
+Tkellem::Daemon.new(ARGV).run()

data/debian/changelog

@@ -0,0 +1,5 @@
+tkellem (0.7.1-1) unstable; urgency=low
+
+  * Initial packaging
+
+ -- paul cannon <pik@debian.org>  Thu, 16 Dec 2010 11:58:18 -0600

data/debian/compat

@@ -0,0 +1 @@
+7

data/debian/control

@@ -0,0 +1,18 @@
+Source: tkellem
+Section: net
+Priority: extra
+Maintainer: paul cannon <pik@debian.org>
+Build-Depends: debhelper (>= 7.0.50~)
+Standards-Version: 3.9.1
+Homepage: https://github.com/codekitchen/tkellem
+
+Package: tkellem
+Architecture: all
+Depends: ${misc:Depends}, ruby, rubygems, libeventmachine-ruby
+Description: IRC bouncer with multi-client support
+ tkellem is an IRC bouncer, a proxy that keeps you permanently logged on to an
+ IRC server and stores all messages so that when your client next connects, you
+ can see the backlog of what happened while you were gone.
+ .
+ tkellem supports multiple device-independent backlogs, and connecting to
+ multiple IRC servers all from the same process.

data/debian/copyright

@@ -0,0 +1,42 @@
+This work was packaged for Debian by:
+
+    paul cannon <pik@debian.org> on Thu, 16 Dec 2010 11:58:18 -0600
+
+It was downloaded from:
+
+    https://github.com/codekitchen/tkellem
+
+Upstream Author(s):
+
+    Brian Palmer
+
+Copyright:
+
+    Copyright (c) 2010 Brian Palmer <brian@codekitchen.net>
+
+License:
+
+    Permission is hereby granted, free of charge, to any person obtaining a
+    copy of this software and associated documentation files (the "Software"),
+    to deal in the Software without restriction, including without limitation
+    the rights to use, copy, modify, merge, publish, distribute, sublicense,
+    and/or sell copies of the Software, and to permit persons to whom the
+    Software is furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in
+    all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+    DEALINGS IN THE SOFTWARE.
+
+The Debian packaging is:
+
+    Copyright (C) 2010 paul cannon <pik@debian.org>
+
+and may be distributed and used under the same terms as the underlying work
+(see above).

data/debian/docs

@@ -0,0 +1 @@
+README.md

data/debian/examples

@@ -0,0 +1 @@
+examples/config.yml

data/debian/install

@@ -0,0 +1,3 @@
+bin/tkellem       /usr/bin
+lib/tkellem.rb    /usr/lib/ruby/1.8
+lib/tkellem/*.rb  /usr/lib/ruby/1.8/tkellem

data/debian/manpages

@@ -0,0 +1 @@
+debian/tkellem.1

data/debian/rules

@@ -0,0 +1,13 @@
+#!/usr/bin/make -f
+# -*- makefile -*-
+# Sample debian/rules that uses debhelper.
+# This file was originally written by Joey Hess and Craig Small.
+# As a special exception, when this file is copied by dh-make into a
+# dh-make output file, you may use that output file without restriction.
+# This special exception was added by Craig Small in version 0.37 of dh-make.
+
+# Uncomment this to turn on verbose mode.
+#export DH_VERBOSE=1
+
+%:
+	dh $@ 

data/debian/source/format

@@ -0,0 +1 @@
+3.0 (quilt)

data/debian/tkellem.1

@@ -0,0 +1,11 @@
+.\" DO NOT MODIFY THIS FILE!  It was generated by help2man 1.38.2.
+.TH TKELLEM "1" "December 2010" "Brian Palmer" "User Commands"
+.SH NAME
+tkellem \- tkellem
+.SH SYNOPSIS
+.B tkellem
+\fIPATH_TO_CONFIG\fR
+.SH DESCRIPTION
+Start a tkellem instance using the specified configuration file (or ~/.tkellem/config.yml if none given)
+.HP
+\fB\-h\fR, \fB\-\-help\fR

data/examples/config.yml

@@ -1,29 +1,2 @@
-#     $ bin/tkellem examples/config.yml
-#
-# to connect: connect to localhost port 10001, ssl enabled, "real name" set to
-#
-#     <connection_name> <client_name>
-#
-# e.g.:
-#
-#     freenode laptop
---- 
-listen: 0.0.0.0
-port: 10001
-ssl: true
-# max_backlog: 500
-connections: 
-  freenode:
-    host: irc.freenode.org
-    port: 6667
-    ssl: false
-    nick: tkellem_r0ck
-    # Uncomment to enable password auth (there's no auth by default, which
-    # means anybody can connect). You can generate a password_sha1 like so:
-    #     echo -n 'tkellem_r0ck' | openssl sha1
-    # password_sha1: a4f4a3b97c7b8a028d4e3f3fee85d6e5626baba5
-    rooms: 
-    - name: "#tkellem_test"
-    clients: 
-    - name: laptop
-    - name: iphone
+#     this file is deprecated, settings are now stored in ~/.tkellem/tkellem.sqlite3
+#     more help to come

data/lib/tkellem/bouncer.rb

@@ -1,52 +1,217 @@
-require 'eventmachine'
+require 'active_support/core_ext/class/attribute_accessors'
 
 require 'tkellem/irc_server'
+require 'tkellem/bouncer_connection'
 
 module Tkellem
-  class Bouncer
-    def initialize(listen_address, port, do_ssl)
-      @irc_servers = {}
-      @max_backlog = nil
-      @server = EM.start_server(listen_address, port, BouncerConnection,
-                                self, do_ssl)
+
+class Bouncer
+  include Tkellem::EasyLogger
+
+  attr_reader :user, :network, :nick
+  cattr_accessor :plugins
+  self.plugins = []
+
+  def initialize(network_user)
+    @network_user = network_user
+    @user = network_user.user
+    @network = network_user.network
+
+    @nick = network_user.nick
+    # maps { client_conn => state_hash }
+    @active_conns = {}
+    @welcomes = []
+    @rooms = ['#tk']
+    # maps { client_conn => away_status_or_nil }
+    @away = {}
+    # plugin data
+    @data = {}
+    # clients waiting for us to connect to the irc server
+    @waiting_clients = []
+
+    connect!
+  end
+
+  def data(key)
+    @data[key] ||= {}
+  end
+
+  def active_conns
+    @active_conns.keys
+  end
+
+  def self.add_plugin(plugin)
+    self.plugins << plugin
+  end
+
+  def connected?
+    !!@connected
+  end
+
+  def connect_client(client)
+    @active_conns[client] = {}
+    @away[client] = nil
+
+    if !connected?
+      @waiting_clients << client
+      client.say_as_tkellem("Connecting you to the IRC server. Please wait...")
+      return
+    end
+
+    send_welcome(client)
+    # make the client join all the rooms that we're in
+    @rooms.each { |room| client.simulate_join(room) }
+
+    plugins.each { |plugin| plugin.new_client_connected(self, client) }
+    check_away_status
+  end
+
+  def disconnect_client(client)
+    @away.delete(client)
+    check_away_status
+    @active_conns.delete(client)
+  end
+
+  def client_msg(client, msg)
+    return if plugins.any? do |plugin|
+      !plugin.client_msg(self, client, msg)
+    end
+
+    forward = case msg.command
+    when 'PING'
+      client.send_msg(":tkellem!tkellem PONG tkellem :#{msg.args.last}")
+      false
+    when 'AWAY'
+      @away[client] = msg.args.last
+      check_away_status
+      false
+    else
+      true
     end
 
-    def add_irc_server(name, host, port, do_ssl, nick)
-      server = EM.connect(host, port, IrcServer, self, name, do_ssl, nick)
-      @irc_servers[name] = server
-      server.set_max_backlog(@max_backlog) if @max_backlog
-      server
+    if forward
+      # send to server
+      send_msg(msg)
     end
+  end
 
-    def remove_irc_server(name)
-      server = @irc_servers.delete(name)
-      if server
-        server.close_connection(true)
-      end
+  def server_msg(msg)
+    return if plugins.any? do |plugin|
+      !plugin.server_msg(self, msg)
     end
 
-    def on_authenticate(&block)
-      @auth_block = block
+    forward = case msg.command
+    when /0\d\d/, /2[56]\d/, /37[256]/
+      @welcomes << msg
+      ready! if msg.command == "376" # end of MOTD
+      false
+    when 'JOIN'
+      debug "#{msg.target_user} joined #{msg.args.last}"
+      @rooms << msg.args.last if msg.target_user == @nick
+      true
+    when 'PART'
+      debug "#{msg.target_user} left #{msg.args.last}"
+      @rooms.delete(msg.args.last) if msg.target_user == @nick
+      true
+    when 'PING'
+      send_msg("PONG tkellem!tkellem :#{msg.args.last}")
+      false
+    when 'PONG'
+      # swallow it, we handle ping-pong from clients separately, in
+      # BouncerConnection
+      false
+    else
+      true
     end
 
-    def max_backlog=(max_backlog)
-      @max_backlog = max_backlog && max_backlog > 0 ? max_backlog : nil
-      @irc_servers.each { |name, server| server.set_max_backlog(@max_backlog) }
+    if forward
+      # send to clients
+      @active_conns.each { |c,s| c.send_msg(msg) }
     end
+  end
 
+  ## Away Statuses
 
-    # Internal API
+  def check_away_status
+    # for now we pretty much randomly pick an away status if multiple are set
+    # by clients
+    if @away.any? { |k,v| !v }
+      # we have a client who isn't away
+      send_msg("AWAY")
+    else
+      message = @away.values.first || "Away"
+      send_msg("AWAY :#{message}")
+    end
+  end
+
+
+  def name
+    "#{user.name}-#{network.name}"
+  end
+  alias_method :log_name, :name
+
+  def send_msg(msg)
+    trace "to server: #{msg}"
+    @conn.send_data("#{msg}\r\n")
+  end
+
+  def connection_established
+    # TODO: support sending a real username, realname, etc
+    send_msg("USER #{@nick} localhost blah :#{@nick}")
+    change_nick(@nick, true)
+    check_away_status
+  end
+
+  def disconnected!
+    debug "OMG we got disconnected."
+    @conn = nil
+    @connected = false
+    @active_conns.each { |c,s| c.unbind }
+    connect!
+  end
 
-    def get_irc_server(name) #:nodoc:
-      @irc_servers[name]
+  protected
+
+  def change_nick(new_nick, force = false)
+    return if !force && new_nick == @nick
+    @nick = new_nick
+    send_msg("NICK #{new_nick}")
+  end
+
+  def send_welcome(bouncer_conn)
+    @welcomes.each { |msg| bouncer_conn.send_msg(msg) }
+  end
+
+  def connect!
+    span = @last_connect ? Time.now - @last_connect : 1000
+    hosts = @network.hosts(true).map { |h| h }
+
+    if span < 5 || hosts.length < 1
+      EM.add_timer(5) { connect! }
+      return
+    end
+    @last_connect = Time.now
+    @cur_host = (@cur_host || 0) % hosts.length
+    host = hosts[@cur_host]
+    @conn = EM.connect(host.address, host.port, IrcServerConnection, self, host.ssl)
+  end
+
+  def ready!
+    return if @joined_rooms
+    @joined_rooms = true
+    @rooms.each do |room|
+      send_msg("JOIN #{room}")
     end
 
-    def do_auth(username, password, irc_server) #:nodoc:
-      if @auth_block
-        @auth_block.call(username, password.to_s, irc_server)
-      else
-        true
-      end
+    # We're all initialized, allow connections
+    @connected = true
+    @waiting_clients.each do |client|
+      client.say_as_tkellem("Now connected.")
+      connect_client(client)
     end
+    @waiting_clients.clear
   end
+
+end
+
 end