tkellem 0.7.1 → 0.8.0

data/lib/tkellem/models/user.rb

@@ -0,0 +1,56 @@
+module Tkellem
+
+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)
+
+  # 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
+  # necessary.
+  cattr_accessor :authentication_methods
+  self.authentication_methods = []
+
+  # default database-based authentication
+  # TODO: proper password hashing
+  self.authentication_methods << proc do |username, password|
+    user = find_by_username(username)
+    user && user.valid_password?(password) && user
+  end
+
+  def self.authenticate(username, password)
+    authentication_methods.each do |m|
+      result = m.call(username, password)
+      return result if result.is_a?(self)
+    end
+    nil
+  end
+
+  def username=(val)
+    write_attribute(:username, val.try(:downcase))
+  end
+
+  def name
+    username
+  end
+
+  def valid_password?(password)
+    require 'openssl'
+    self.password == OpenSSL::Digest::SHA1.hexdigest(password)
+  end
+
+  def set_password!(password)
+    self.password = OpenSSL::Digest::SHA1.hexdigest(password)
+    self.save!
+  end
+
+  def admin?
+    role == 'admin'
+  end
+end
+
+end

data/lib/tkellem/plugins/backlog.rb

@@ -0,0 +1,160 @@
+require 'fileutils'
+require 'time'
+
+require 'active_support/core_ext/class/attribute_accessors'
+
+require 'tkellem/irc_message'
+
+module Tkellem
+
+# The default backlog handler. Stores messages, and allows for
+# device-independent backlogs (if the client sends a device_name, that device
+# will get its own backlog cursor).
+
+# This is implemented as a plugin -- in theory, it could be switched out for a
+# different backlog implementation. Right now, it's always loaded though.
+class Backlog
+  include Tkellem::EasyLogger
+
+  Bouncer.add_plugin(self)
+  cattr_accessor :instances
+
+  def self.get_instance(bouncer)
+    bouncer.data(self)[:instance] ||= self.new(bouncer)
+  end
+
+  def self.new_client_connected(bouncer, client)
+    instance = get_instance(bouncer)
+    instance.client_connected(client)
+  end
+
+  def self.client_msg(bouncer, client, msg)
+    instance = get_instance(bouncer)
+    instance.client_msg(msg)
+    true
+  end
+
+  def self.server_msg(bouncer, msg)
+    instance = get_instance(bouncer)
+    instance.server_msg(msg)
+    true
+  end
+
+  def initialize(bouncer)
+    @bouncer = bouncer
+    @devices = {}
+    @streams = {}
+    @starting_pos = {}
+    @dir = File.expand_path("~/.tkellem/logs/#{bouncer.user.name}/#{bouncer.network.name}")
+    FileUtils.mkdir_p(@dir)
+  end
+
+  def stream_filename(ctx)
+    File.join(@dir, "#{ctx}.log")
+  end
+
+  def get_stream(ctx)
+    # open stream in append-only mode
+    return @streams[ctx] if @streams[ctx]
+    stream = @streams[ctx] = File.open(stream_filename(ctx), 'ab')
+    @starting_pos[ctx] = stream.pos
+    stream
+  end
+
+  def get_device(conn)
+    @devices[conn.device_name] ||= Hash.new { |h,k| h[k] = @starting_pos[k] }
+  end
+
+  def client_connected(conn)
+    device = get_device(conn)
+    if @streams.any? { |ctx_name, stream| device[ctx_name] < stream.pos }
+      # this device has missed messages, replay all the backlogs
+      send_backlog(conn, device)
+    end
+  end
+
+  def update_pos(ctx_name, pos)
+    @bouncer.active_conns.each do |conn|
+      device = get_device(conn)
+      device[ctx_name] = pos
+    end
+  end
+
+  def log_name
+    "backlog:#{@bouncer.log_name}"
+  end
+
+  def server_msg(msg)
+    case msg.command
+    when /3\d\d/, 'JOIN', 'PART'
+      # transient messages
+      return
+    when 'PRIVMSG'
+      ctx = msg.args.first
+      if ctx == @bouncer.nick
+        # incoming pm, fake ctx to be the sender's nick
+        ctx = msg.prefix.split(/[!~@]/, 2).first
+      end
+      stream = get_stream(ctx)
+      stream.puts(Time.now.strftime("%d-%m-%Y %H:%M:%S < #{msg.prefix}: #{msg.args.last}"))
+      update_pos(ctx, stream.pos)
+    end
+  end
+
+  def client_msg(msg)
+    case msg.command
+    when 'PRIVMSG'
+      ctx = msg.args.first
+      stream = get_stream(ctx)
+      stream.puts(Time.now.strftime("%d-%m-%Y %H:%M:%S > #{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
+        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
+        end
+        conn.send_msg(msg.with_timestamp(timestamp))
+      end
+
+      device[ctx_name] = get_stream(ctx_name).pos
+    end
+  end
+
+  def parse_line(line, ctx_name)
+    timestamp = Time.parse(line[0, 19])
+    case line[20..-1]
+    when %r{^> (.+)$}
+      msg = IrcMessage.new(nil, 'PRIVMSG', [ctx_name, $1])
+      return timestamp, msg
+    when %r{^< ([^:]+): (.+)$}
+      msg = IrcMessage.new($1, 'PRIVMSG', [ctx_name, $2])
+      return timestamp, msg
+    else
+      nil
+    end
+  end
+end
+
+end

data/lib/tkellem/plugins/push_service.rb

@@ -0,0 +1,152 @@
+require 'eventmachine'
+require 'json'
+require 'tkellem/irc_message'
+
+module Tkellem
+
+# http://colloquy.mobi/bouncers.html
+class PushService
+  include Tkellem::EasyLogger
+
+  attr_reader :server, :port, :device_token
+
+  def self.connections
+    @connections || @connections = {}
+  end
+
+  def self.active_instances
+    # TODO: need to time these out after some period -- a week or something
+    @instances || @instances = {}
+  end
+
+  Bouncer.add_plugin(self)
+
+  def self.new_client_connected(bouncer, client)
+  end
+
+  def self.client_msg(bouncer, client, msg)
+    # TODO: check if push services enabled
+    case msg.command
+    when 'PUSH'
+      if service = client.data(self)[:instance]
+        service.client_message(msg)
+      elsif msg.args.first != 'add-device'
+        # TODO: return error to client?
+      else
+        service = PushService.new(bouncer, msg)
+        # This will replace the old one for the same device, if it exists
+        active_instances[service.device_token] = service
+        client.data(self)[:instance] = service
+      end
+      false
+    else
+      true
+    end
+  end
+
+  def self.server_msg(bouncer, msg)
+    active_instances.each { |token, service| service.handle_message(msg) }
+  end
+
+  def self.stop_service(push_service)
+    active_instances.delete(push_service.device_token)
+  end
+
+  def log_name
+    "#{@bouncer.log_name}:#{@device_token}"
+  end
+
+  def initialize(bouncer, add_device_msg)
+    @bouncer = bouncer
+    @device_token, @device_name = add_device_msg.args[1,2]
+  end
+
+  def client_message(msg)
+    raise("only push plz") unless msg.command == 'PUSH'
+    case msg.args.first
+    when 'add-device'
+      # shouldn't get this again
+    when 'service'
+      @server, @port = msg.args[1,2].map { |a| a.downcase }
+      ensure_connection
+    when 'connection'
+      # TODO: what's this for
+    when 'highlight-word'
+      # TODO: custom highlight words
+    when 'highlight-sound'
+      @highlight_sound = msg.args.last
+    when 'message-sound'
+      @message_sound = msg.args.last
+    when 'end-device'
+    when 'remove-device'
+      self.class.stop_service(self)
+    end
+  end
+
+  def handle_message(msg)
+    return unless @connection
+    case msg.command
+    when /privmsg/i
+      send_message(msg) if msg.args.last =~ /#{@bouncer.nick}/
+    end
+  end
+
+  def send_message(msg)
+    trace "forwarding #{msg} for #{@device_token}"
+    sender = msg.prefix.split('!', 2).first
+    room = msg.args.first
+
+    args = {
+      'device-token' => @device_token,
+      'message' => msg.args.last.to_s,
+      'sender' => sender,
+      'room' => msg.args.first,
+      'server' => 'blah',
+      'badge' => 1,
+    }
+    args['sound'] = @message_sound if @message_sound
+    @connection.send_data(args.to_json) if @connection
+  end
+
+  def ensure_connection
+    @connection = self.class.connections[[@server, @port]] ||=
+      EM.connect(@server, @port, PushServiceConnection, self, @server, @port)
+  end
+
+  def lost_connection
+    self.class.connections.delete([@server, @port])
+    @connection = nil
+    ensure_connection
+  end
+end
+
+module PushServiceConnection
+  include Tkellem::EasyLogger
+
+  def initialize(service, server, port)
+    @service = service
+    @server = server
+    @port = port
+  end
+
+  def post_init
+    start_tls :verify_peer => false
+  end
+
+  def log_name
+    "#{@server}:#{@port}"
+  end
+
+  def ssl_handshake_completed
+    debug "connected to push service #{@server}:#{@port}"
+    @connected = true
+  end
+
+  def unbind
+    debug "lost connection to push service #{@server}:#{@port}"
+    @connected = false
+    @service.lost_connection
+  end
+end
+
+end

data/lib/tkellem/socket_server.rb

@@ -0,0 +1,29 @@
+require 'eventmachine'
+
+require 'tkellem/tkellem_bot'
+
+module Tkellem
+
+# listens on the unix domain socket and executes admin commands
+module SocketServer
+  include EM::Protocols::LineText2
+  include Tkellem::EasyLogger
+
+  def log_name
+    "admin"
+  end
+
+  def post_init
+    set_delimiter "\n"
+  end
+
+  def receive_line(line)
+    trace "admin socket: #{line}"
+    TkellemBot.run_command(line, nil) do |line|
+      send_data("#{line}\n")
+    end
+    send_data("\0\n")
+  end
+end
+
+end

data/lib/tkellem/tkellem_bot.rb

@@ -0,0 +1,318 @@
+require 'shellwords'
+require 'yaml'
+
+module Tkellem
+
+class TkellemBot
+  # careful here -- if no user is given, it's assumed the command is running as
+  # an admin
+  def self.run_command(line, user, &block)
+    args = Shellwords.shellwords(line.downcase)
+    command_name = args.shift.upcase
+    command = commands[command_name]
+
+    unless command
+      yield "Invalid command. Use help for a command listing."
+      return
+    end
+
+    command.run(args, user, block)
+  end
+
+  class Command
+    attr_accessor :args
+
+    def self.options
+      unless defined?(@options)
+        @options = OptionParser.new
+        class << @options
+          attr_accessor :cmd
+          def set(name, *args)
+            self.on(*args) { |v| cmd.args[name] = v }
+          end
+        end
+      end
+      @options
+    end
+
+    def options
+      self.class.options
+    end
+
+    def self.register(cmd_name)
+      cattr_accessor :name
+      self.name = cmd_name
+      TkellemBot.commands[name.upcase] = self
+      self.options.banner = resources(name)['banner'] if resources(name)['banner']
+      self.options.separator(resources(name)['help']) if resources(name)['help']
+    end
+
+    def self.resources(name)
+      @resources ||= YAML.load_file(File.expand_path("../../../resources/bot_command_descriptions.yml", __FILE__))
+      @resources[name.upcase] || {}
+    end
+
+    class ArgumentError < RuntimeError; end
+
+    def self.admin_only?
+      false
+    end
+
+    def self.run(args_arr, user, block)
+      if admin_only? && !admin_user?(user)
+        block.call "You can only run #{name} as an admin."
+        return
+      end
+      cmd = self.new(block)
+      options.cmd = cmd
+      options.parse!(args_arr)
+      cmd.args[:rest] = args_arr
+      cmd.execute(cmd.args, user)
+    rescue ArgumentError => e
+      cmd.respond e.to_s
+      cmd.show_help
+    end
+
+    def initialize(responder)
+      @responder = responder
+      @args = {}
+    end
+
+    def show_help
+      respond(options.to_s)
+    end
+
+    def respond(text)
+      text.each_line { |l| @responder.call(l.chomp) }
+    end
+    alias_method :r, :respond
+
+    def self.admin_user?(user)
+      !user || user.admin?
+    end
+  end
+
+  cattr_accessor :commands
+  self.commands = {}
+
+  class Help < Command
+    register 'help'
+
+    def execute(args, user)
+      name = args[:rest].first
+      r "**** tkellem help ****"
+      if name.nil?
+        r "For more information on a command, type:"
+        r "help <command>"
+        r ""
+        r "The following commands are available:"
+        TkellemBot.commands.keys.sort.each do |name|
+          command = TkellemBot.commands[name]
+          next if command.admin_only? && user && !user.admin?
+          r "#{name}#{' ' * (25-name.length)}"
+        end
+      elsif (command = TkellemBot.commands[name.upcase])
+        r "Help for #{command.name}:"
+        r ""
+        r command.options.to_s
+      else
+        r "No help available for #{args.first.upcase}."
+      end
+      r "**** end of help ****"
+    end
+  end
+
+  class CRUDCommand < Command
+    def self.register_crud(name, model)
+      register(name)
+      cattr_accessor :model
+      self.model = model
+      options.set('add', '--add', '-a', "Add a #{model.name}")
+      options.set('remove', '--remove', '-r', "Remove a #{model.name}")
+      options.set('list', '--list', '-l', "List the current #{model.name.pluralize}")
+    end
+
+    def show(m)
+      m.to_s
+    end
+
+    def find_attributes(args, user)
+      attributes(args, user)
+    end
+
+    def list(args, user)
+      r "All #{self.class.name.pluralize}:"
+      model.all.each { |m| r "    #{show(m)}" }
+    end
+
+    def remove(args, user)
+      instance = model.first(:conditions => find_attributes(args, user))
+      if instance
+        instance.destroy
+        respond "Removed #{show(instance)}"
+      else
+        respond "Not found"
+      end
+    end
+
+    def add(args, user)
+      instance = model.create(attributes(args, user))
+      if instance.errors.any?
+        respond "Errors creating:"
+        instance.errors.full_messages.each { |m| respond "    #{m}" }
+      else
+        respond "#{show(instance)} added"
+      end
+    end
+
+    def execute(args, user)
+      if args['list']
+        list(args, user)
+      elsif args['remove']
+        remove(args, user)
+      elsif args['add']
+        add(args, user)
+      else
+        raise Command::ArgumentError, "Unknown sub-command"
+      end
+    end
+  end
+
+  class ListenCommand < CRUDCommand
+    register_crud 'listen', ListenAddress
+
+    def self.admin_only?
+      true
+    end
+
+    def self.get_uri(args)
+      require 'uri'
+      uri = URI.parse(args[:rest].first)
+      unless %w(irc ircs).include?(uri.scheme)
+        raise Command::ArgumentError, "Invalid URI scheme: #{uri}"
+      end
+      uri
+    rescue URI::InvalidURIError
+      raise Command::ArgumentError, "Invalid new address: #{args[:rest].first}"
+    end
+
+    def attributes(args, user)
+      uri = self.class.get_uri(args)
+      { :address => uri.host, :port => uri.port, :ssl => (uri.scheme == 'ircs') }
+    end
+  end
+
+  class UserCommand < CRUDCommand
+    register_crud 'user', User
+
+    def self.admin_only?
+      true
+    end
+
+    options.set('user', '--user', '-u', 'Set new user as user (the default)')
+    options.set('admin', '--admin', 'Set new user as admin')
+
+    def show(user)
+      "#{user.username}:#{user.role}"
+    end
+
+    def find_attributes(args, user)
+      { :username => args[:rest].first }
+    end
+
+    def attributes(args, user)
+      find_attributes(args).merge({ :role => (args['admin'] ? 'admin' : 'user') })
+    end
+  end
+
+  class PasswordCommand < Command
+    register 'password'
+
+    options.set('username', '--user=username', '-u', 'Change password for other username')
+
+    def execute(args, user)
+      if args['username']
+        if Command.admin_user?(user)
+          user = User.first(:conditions => { :username => args['username'] })
+        else
+          raise Command::ArgumentError, "Only admins can change other passwords"
+        end
+      end
+
+      unless user
+        raise Command::ArgumentError, "User required"
+      end
+
+      password = args[:rest].shift || ''
+
+      if password.size < 4
+        raise Command::ArgumentError, "New password too short"
+      end
+
+      user.set_password!(password)
+      respond "New password set for #{user.username}"
+    end
+  end
+
+  class NetworkCommand < CRUDCommand
+    register_crud 'network', Host
+
+    options.set('public', '--public', 'Set new network as public')
+    options.set('username', '--user=username', '-u', 'Create a user-specific network for another user')
+
+    def list(args, user)
+      r "All networks:"
+      Network.all.each { |m| r "    #{show(m.hosts.first)}" if m.hosts.first }
+    end
+
+    def show(host)
+      "#{host.network.name}#{' (public)' if host.network.public?} " + host.network.hosts.map { |h| "[#{h}]" }.join(' ')
+    end
+
+    def get_network(args, user)
+      network_name = args[:rest].shift
+      if args['username']
+        if Command.admin_user?(user)
+          user = User.first(:conditions => { :username => args['username'] })
+        else
+          raise Command::ArgumentError, "Only admins can change other user's networks"
+        end
+      end
+
+      network = Network.first(:conditions => { :name => network_name, :user_id => user.id }) if user
+      network ||= Network.first(:conditions => { :name => network_name, :user_id => nil })
+      if network && network.public? && !self.class.admin_user?(user)
+        raise Command::ArgumentError, "Only admins can modify public networks"
+      end
+      return network_name, network, user
+    end
+
+    def remove(args, user)
+      network_name, network, user = get_network(args, user)
+      if network
+        Host.all(:conditions => { :network_id => network.id }).each(&:destroy)
+        network.destroy
+        respond "Removed #{network.name} #{show(network.hosts.first) if network.hosts.first}"
+      else
+        respond "Not found"
+      end
+    end
+
+    def attributes(args, user)
+      network_name, network, user = get_network(args, user)
+
+      unless network
+        create_public = !user || (user.admin? && args['public'])
+        network = Network.create(:name => network_name, :user => (create_public ? nil : user))
+        unless create_public
+          NetworkUser.create(:user => user, :network => network)
+        end
+      end
+
+      uri = ListenCommand.get_uri(args)
+      { :network => network, :address => uri.host, :port => uri.port, :ssl => (uri.scheme == 'ircs') }
+    end
+  end
+end
+
+end