tkellem 0.8.6 → 0.8.7

data/README.md

@@ -21,10 +21,10 @@ This will have to do as a quickstart guide, for now:
     $ tkellem start
     $ tkellem admin
     > help
-    > listen --add 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
+    > listen ircs://0.0.0.0:8765
+    > user <my-name> --role=admin
+    > password --user=<my-name> <my-new-password>
+    > network --public --name=freenode ircs://irc.freenode.org:7000
 
 Then connect to tkellem with an irc client:
 
@@ -39,3 +39,12 @@ Then connect to tkellem with an irc client:
 Note that all config and log files are stored in ~/.tkellem of the user
 you run `tkellem start` as. You also need to run `tkellem admin` as this
 same user, in order to have access to the admin console.
+
+## Upgrading
+
+Upgrading is as simple as:
+
+    $ gem install tkellem
+    $ tkellem restart
+
+All active clients will be forced to re-connect.

data/lib/tkellem/bouncer.rb

@@ -8,7 +8,7 @@ module Tkellem
 class Bouncer
   include Tkellem::EasyLogger
 
-  attr_reader :user, :network, :nick
+  attr_reader :user, :network, :nick, :network_user, :connected_at
   cattr_accessor :plugins
   self.plugins = []
 
@@ -173,15 +173,16 @@ class Bouncer
   def connection_established(conn)
     @conn = conn
     # TODO: support sending a real username, realname, etc
-    send_msg("USER #{@user.username} somehost tkellem :#{@user.name}")
+    send_msg("USER #{@user.username} somehost tkellem :#{@user.name}@tkellem")
     change_nick(@nick, true)
-    check_away_status
+    @connected_at = Time.now
   end
 
   def disconnected!
     debug "OMG we got disconnected."
     @conn = nil
     @connected = false
+    @connected_at = nil
     @active_conns.each { |c,s| c.unbind }
     connect!
   end
@@ -209,24 +210,25 @@ class Bouncer
     @last_connect = Time.now
     @cur_host = (@cur_host || 0) % hosts.length
     host = hosts[@cur_host]
-    EM.connect(host.address, host.port, IrcServerConnection, self, host.ssl)
+    failsafe("connect: #{host}") do
+      EM.connect(host.address, host.port, IrcServerConnection, self, host.ssl)
+    end
   end
 
   def ready!
-    return if @joined_rooms
-    @joined_rooms = true
     @rooms.each do |room|
       send_msg("JOIN #{room}")
     end
 
+    check_away_status
+
     # We're all initialized, allow connections
+    @connected_at = Time.now
     @connected = true
 
-    @network_user.at_connect.each do |line|
-      cmd, args = line.split(' ', 2)
-      next unless cmd && args && cmd[0] == '/'[0]
-      msg = IrcMessage.parse("#{cmd[1..-1].upcase} #{args}")
-      send_msg(msg)
+    @network_user.combined_at_connect.each do |line|
+      msg = IrcMessage.parse_client_command(line)
+      send_msg(msg) if msg
     end
 
     @waiting_clients.each do |client|

data/lib/tkellem/bouncer_connection.rb

@@ -18,8 +18,9 @@ module BouncerConnection
     @state = :auth
     @name = 'new-conn'
     @data = {}
+    @connected_at = Time.now
   end
-  attr_reader :ssl, :bouncer, :name, :device_name, :connecting_nick
+  attr_reader :ssl, :bouncer, :name, :device_name, :connecting_nick, :connected_at
   alias_method :log_name, :name
 
   def nick
@@ -45,6 +46,7 @@ module BouncerConnection
 
   def error!(msg)
     info("ERROR :#{msg}")
+    say_as_tkellem(msg)
     send_msg("ERROR :#{msg}")
     close_connection(true)
   end
@@ -58,8 +60,28 @@ module BouncerConnection
   end
 
   def msg_tkellem(msg)
-    TkellemBot.run_command(msg.args.join(' '), @user) do |response|
-      say_as_tkellem(response)
+    case @state
+    when :recaptcha
+      if @recaptcha.valid_response?(msg.args.last)
+        say_as_tkellem "Looks like you're human. Whew, I hate robots."
+        user_registration_get_password
+      else
+        say_as_tkellem "Nope, that's not right. Please try again."
+      end
+    when :password
+      user = User.create(:username => @username, :password => msg.args.last, :role => 'user')
+      if user.errors.any?
+        error!("There was an error creating your user account. Please try again, or contact the tkellem admin.")
+      else
+        @user = user
+        say_as_tkellem("Your account has been created. Set your password in your IRC client and re-connect to start using tkellem.")
+      end
+    else
+      if @user
+        TkellemBot.run_command(msg.args.join(' '), @user, @bouncer.try(:network_user)) do |response|
+          say_as_tkellem(response)
+        end
+      end
     end
   end
 
@@ -73,7 +95,7 @@ module BouncerConnection
       msg = IrcMessage.parse(line)
 
       command = msg.command
-      if @user && command == 'PRIVMSG' && msg.args.first == '-tkellem'
+      if @state != :auth && command == 'PRIVMSG' && msg.args.first == '-tkellem'
         msg_tkellem(IrcMessage.new(nil, 'TKELLEM', [msg.args.last]))
       elsif command == 'TKELLEM'
         msg_tkellem(msg)
@@ -105,7 +127,8 @@ module BouncerConnection
   end
 
   def maybe_connect
-    if @connecting_nick && @username && @password && !@user
+    return unless @connecting_nick && @username && !@user
+    if @password
       @name = @username
       @user = User.authenticate(@username, @password)
       return error!("Unknown username: #{@username} or bad password.") unless @user
@@ -122,9 +145,41 @@ module BouncerConnection
         @name = "#{@username}-console"
         connect_to_tkellem_console
       end
+    else
+      user = User.find_by_username(@username)
+      if user || user_registration == 'closed'
+        error!("No password given. Make sure to set your password in your IRC client config, and connect again.")
+        if user_registration != 'closed'
+          error!("If you are trying to register for a new account, this username is already taken. Please select another.")
+        end
+      else
+        @state = :registration
+        say_as_tkellem "Welcome to tkellem, #{@username}. If you already have an account and were trying to connect, please check your username, as it wasn't recognized."
+        say_as_tkellem "Otherwise, follow these instructions to create an account."
+        say_as_tkellem ' '
+        if recaptcha = Setting.get('recaptcha_api_key').presence
+          @state = :recaptcha
+          require 'tkellem/plugins/recaptcha'
+          @recaptcha = Recaptcha.new(*recaptcha.split(',', 2))
+          say_as_tkellem "First, you'll need to take a captcha test to verify that you aren't an evil robot bent on destroying humankind."
+          say_as_tkellem "Visit this URL, and tell me the code you are given after solving the captcha: #{@recaptcha.challenge_url}"
+          return
+        end
+        user_registration_get_password
+      end
     end
   end
 
+  def user_registration
+    val = Setting.get('user_registration')
+    %(open verified).include?(val) ? val : 'closed'
+  end
+
+  def user_registration_get_password
+    @state = :password
+    say_as_tkellem "You need to set an initial password for your account. Enter your password now:"
+  end
+
   def connect_to_tkellem_console
     send_msg(":tkellem 001 #{nick} :Welcome to the Tkellem admin console")
     send_msg(":tkellem 376 #{nick} :End")

data/lib/tkellem/irc_message.rb

@@ -28,6 +28,18 @@ class IrcMessage < Struct.new(:prefix, :command, :args, :ctcp)
     msg
   end
 
+  # parse a command as it'd come from a client, e.g.
+  # /nick newnick
+  #   or
+  # /msg #someroom hey guys
+  def self.parse_client_command(line)
+    return nil unless line[0] == '/'[0]
+    msg = parse(line[1..-1])
+    return nil unless msg
+    msg.command = 'PRIVMSG' if msg.command == 'MSG'
+    msg
+  end
+
   def ctcp?
     self.ctcp.present?
   end

data/lib/tkellem/migrations/003_settings.rb

@@ -0,0 +1,13 @@
+class Settings < ActiveRecord::Migration
+  def self.up
+    create_table 'settings' do |t|
+      t.string :name, :null => false
+      t.string :value, :null => false
+      t.boolean :unchanged, :null => false, :default => true
+    end
+
+    Tkellem::Setting.make_new('user_registration', 'closed')
+    Tkellem::Setting.make_new('recaptcha_api_key', '')
+    Tkellem::Setting.make_new('allow_user_networks', 'false')
+  end
+end

data/lib/tkellem/models/network.rb

@@ -2,11 +2,15 @@ module Tkellem
 
 class Network < ActiveRecord::Base
   has_many :hosts, :dependent => :destroy
+  accepts_nested_attributes_for :hosts
+
   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
 
+  validates_uniqueness_of :name, :scope => :user_id
+
   serialize :at_connect, Array
 
   def at_connect

data/lib/tkellem/models/network_user.rb

@@ -10,10 +10,8 @@ class NetworkUser < ActiveRecord::Base
     read_attribute(:nick) || user.name
   end
 
-  # we use the network's at_connect until it is modified and overwritten for
-  # this specific network user
-  def at_connect
-    network.at_connect + (read_attribute(:at_connect) || [])
+  def combined_at_connect
+    network.at_connect + (at_connect || [])
   end
 end
 

data/lib/tkellem/models/setting.rb

@@ -0,0 +1,24 @@
+module Tkellem
+
+class Setting < ActiveRecord::Base
+  def self.get(setting_name)
+    setting = first(:conditions => { :name => setting_name })
+    setting.try(:value)
+  end
+
+  def self.set(setting_name, new_value)
+    setting = first(:conditions => { :name => setting_name })
+    setting.try(:update_attributes, :value => new_value.to_s, :unchanged => false)
+    setting
+  end
+
+  def self.make_new(setting_name, default_value)
+    create!(:name => setting_name, :value => default_value.to_s, :unchanged => true)
+  end
+
+  def to_s
+    "#{name}: #{value}"
+  end
+end
+
+end

data/lib/tkellem/models/user.rb

@@ -43,11 +43,6 @@ class User < ActiveRecord::Base
     self.password == OpenSSL::Digest::SHA1.hexdigest(password)
   end
 
-  def set_password!(password)
-    self.password = password
-    self.save!
-  end
-
   def password=(password)
     write_attribute(:password, password ? OpenSSL::Digest::SHA1.hexdigest(password) : nil)
   end

data/lib/tkellem/plugins/recaptcha.rb

@@ -0,0 +1,35 @@
+require 'openssl'
+
+module Tkellem
+
+class Recaptcha
+  def initialize(public_key, private_key)
+    @public_key = public_key
+    @private_key = private_key
+    @secret = ActiveSupport::SecureRandom.hex(16)
+  end
+
+  def challenge_url
+    "http://www.google.com/recaptcha/mailhide/d?k=#{@public_key}&c=#{url_encoded_secret}"
+  end
+
+  def encrypted_secret
+    cipher = OpenSSL::Cipher::Cipher.new('aes-128-cbc')
+    cipher.encrypt
+    cipher.iv = "\x00"*16
+    cipher.key = [@private_key].pack("H*") # private key is a hex string
+    data = cipher.update(@secret)
+    data << cipher.final
+    data
+  end
+
+  def url_encoded_secret
+    [encrypted_secret].pack('m').strip.gsub("\n", '').tr('+/', '-_')
+  end
+
+  def valid_response?(response)
+    response.strip == @secret
+  end
+end
+
+end

data/lib/tkellem/socket_server.rb

@@ -19,7 +19,7 @@ module SocketServer
 
   def receive_line(line)
     trace "admin socket: #{line}"
-    TkellemBot.run_command(line, nil) do |line|
+    TkellemBot.run_command(line, nil, nil) do |line|
       send_data("#{line}\n")
     end
     send_data("\0\n")

data/lib/tkellem/tkellem_bot.rb

@@ -6,8 +6,8 @@ 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)
+  def self.run_command(line, user, network_user, &block)
+    args = Shellwords.shellwords(line)
     command_name = args.shift.upcase
     command = commands[command_name]
 
@@ -16,35 +16,27 @@ class TkellemBot
       return
     end
 
-    command.run(args, user, block)
+    command.run(args, user, network_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
+    attr_accessor :args, :user, :network_user, :opts, :options
+
+    def self.option(name, *args)
+      @options ||= {}
+      @options[name] = args
     end
 
-    def options
-      self.class.options
+    def self.admin_option(name, *args)
+      option(name, *args)
+      @admin_onlies ||= []
+      @admin_onlies << name
     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)
@@ -55,35 +47,51 @@ class TkellemBot
     class ArgumentError < RuntimeError; end
 
     def self.admin_only?
-      false
+      true
     end
 
-    def self.run(args_arr, user, block)
+    def self.build_options(user, cmd = nil)
+      OptionParser.new.tap do |options|
+        @options.try(:each) { |opt_name,args|
+          next if !admin_user?(user) && @admin_onlies.include?(opt_name)
+          options.on(*args) { |v| cmd.opts[opt_name] = v }
+        }
+        resources = self.resources(name)
+        options.banner = resources['banner'] if resources['banner']
+        options.separator(resources['help']) if resources['help']
+      end
+    end
+
+    def self.run(args_arr, user, network_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.args = args_arr
+      cmd.user = user
+      cmd.network_user = network_user
+
+      cmd.options = build_options(user, cmd)
+      cmd.options.parse!(args_arr)
+
+      cmd.execute
+    rescue ArgumentError, OptionParser::InvalidOption => e
       cmd.respond e.to_s
-      cmd.show_help
     end
 
     def initialize(responder)
       @responder = responder
-      @args = {}
+      @opts = {}
     end
 
     def show_help
-      respond(options.to_s)
+      respond(options)
     end
 
     def respond(text)
-      text.each_line { |l| @responder.call(l.chomp) }
+      text.to_s.each_line { |l| @responder.call(l.chomp) }
     end
     alias_method :r, :respond
 
@@ -98,8 +106,12 @@ class TkellemBot
   class Help < Command
     register 'help'
 
-    def execute(args, user)
-      name = args[:rest].first
+    def self.admin_only?
+      false
+    end
+
+    def execute
+      name = args.shift.try(:upcase)
       r "**** tkellem help ****"
       if name.nil?
         r "For more information on a command, type:"
@@ -111,12 +123,12 @@ class TkellemBot
           next if command.admin_only? && user && !user.admin?
           r "#{name}#{' ' * (25-name.length)}"
         end
-      elsif (command = TkellemBot.commands[name.upcase])
+      elsif (command = TkellemBot.commands[name])
         r "Help for #{command.name}:"
         r ""
-        r command.options.to_s
+        r command.build_options(user)
       else
-        r "No help available for #{args.first.upcase}."
+        r "No help available for #{name}."
       end
       r "**** end of help ****"
     end
@@ -127,51 +139,64 @@ class TkellemBot
       register(name)
       cattr_accessor :model
       self.model = model
-      options.set('add', '--add', '-a', "Add a #{model}")
-      options.set('remove', '--remove', '-r', "Remove a #{model}")
-      options.set('list', '--list', '-l', "List the current #{model.to_s.pluralize}")
+      option('remove', '--remove', '-r', "delete the specified record")
     end
 
     def show(m)
       m.to_s
     end
 
-    def find_attributes(args, user)
-      attributes(args, user)
+    def find_attributes
+      attributes
     end
 
-    def list(args, user)
+    def list
       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))
+    def modify
+      instance = model.first(:conditions => find_attributes)
+      new_record = false
       if instance
-        instance.destroy
-        respond "Removed #{show(instance)}"
+        instance.attributes = attributes
+        if instance.changed?
+          instance.save
+        else
+          respond "   #{show(instance)}"
+          return
+        end
       else
-        respond "Not found"
+        new_record = true
+        instance = model.create(attributes)
       end
-    end
-
-    def add(args, user)
-      instance = model.create(attributes(args, user))
       if instance.errors.any?
-        respond "Errors creating:"
+        respond "Error:"
         instance.errors.full_messages.each { |m| respond "    #{m}" }
+        respond "    #{show(instance)}"
       else
-        respond "#{show(instance)} added"
+        respond(new_record ? "created:" : "updated:")
+        respond "    #{show(instance)}"
       end
     end
 
-    def execute(args, user)
-      if args['list']
-        list(args, user)
-      elsif args['remove']
-        remove(args, user)
-      elsif args['add']
-        add(args, user)
+    def remove
+      instance = model.first(:conditions => find_attributes)
+      if instance
+        instance.destroy
+        respond "Removed #{show(instance)}"
+      else
+        respond "Not found"
+      end
+    end
+
+    def execute
+      if opts['remove'] && args.length == 1
+        remove
+      elsif args.length == 0
+        list
+      elsif args.length == 1
+        modify
       else
         raise Command::ArgumentError, "Unknown sub-command"
       end
@@ -181,23 +206,19 @@ class TkellemBot
   class ListenCommand < CRUDCommand
     register_crud 'listen', ListenAddress
 
-    def self.admin_only?
-      true
-    end
-
-    def self.get_uri(args)
+    def self.get_uri(arg)
       require 'uri'
-      uri = URI.parse(args[:rest].first)
+      uri = URI.parse(arg)
       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}"
+      raise Command::ArgumentError, "Invalid new address: #{arg}"
     end
 
-    def attributes(args, user)
-      uri = self.class.get_uri(args)
+    def attributes
+      uri = self.class.get_uri(args.first)
       { :address => uri.host, :port => uri.port, :ssl => (uri.scheme == 'ircs') }
     end
   end
@@ -205,33 +226,37 @@ class TkellemBot
   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')
+    option('role', '--role=ROLE', 'Set user role [admin|user]')
 
     def show(user)
       "#{user.username}:#{user.role}"
     end
 
-    def find_attributes(args, user)
-      { :username => args[:rest].first }
+    def find_attributes
+      { :username => args.first.downcase }
     end
 
-    def attributes(args, user)
-      find_attributes(args, user).merge({ :role => (args['admin'] ? 'admin' : 'user') })
+    def attributes
+      find_attributes.tap { |attrs|
+        role = opts['role'].try(:downcase)
+        attrs['role'] = role if %w(user admin).include?(role)
+      }
     end
   end
 
   class PasswordCommand < Command
     register 'password'
 
-    options.set('username', '--user=username', '-u', 'Change password for other username')
+    admin_option('username', '--user=username', '-u', 'Change password for other username')
+
+    def self.admin_only?
+      false
+    end
 
-    def execute(args, user)
-      if args['username']
+    def execute
+      user = self.user
+
+      if opts['username']
         if Command.admin_user?(user)
           user = User.first(:conditions => { :username => args['username'] })
         else
@@ -243,111 +268,193 @@ class TkellemBot
         raise Command::ArgumentError, "User required"
       end
 
-      password = args[:rest].shift || ''
+      password = args.shift || ''
 
       if password.size < 4
         raise Command::ArgumentError, "New password too short"
       end
 
-      user.set_password!(password)
+      user.password = password
+      user.save!
       respond "New password set for #{user.username}"
     end
   end
 
-  class AtConnectCommand < CRUDCommand
-    register_crud 'atconnect', 'At-Connect'
+  class AtConnectCommand < Command
+    register 'atconnect'
 
-    # options.set('network', '--network=network', '-n', 'Network to modify at-connect on')
-    options.set('username', '--user=username', '-u', 'Modify a user-specific network for another user')
+    option('remove', '--remove', '-r', 'Remove previously configured command')
+    admin_option('network', '--network=network', '-n', 'Change atconnect for all users on a public network')
 
-    def list(args, user, network = nil)
-      network_name, network, user = NetworkCommand.get_network(args, user) unless network
-      raise(Command::ArgumentError, "No network found") unless network
-      r "At connect:"
-      network.at_connect.each { |line| r "    /#{line}" }
+    def self.admin_only?
+      false
     end
 
-    def remove(args, user)
-      network_name, network, user = NetworkCommand.get_network(args, user)
-      raise(Command::ArgumentError, "No network found") unless network
-      line = args[:rest].join(' ')
-      network.at_connect = network.at_connect.reject { |l| l == line }
-      network.save
-      list(args, user, network)
+    def list(target)
+      target.reload
+      if target.is_a?(NetworkUser) && target.network.public?
+        r "Network-wide commands are prefixed with [N], user-specific commands with [U]."
+        r "Network-wide commands can only be modified by admins."
+        list(target.network)
+      end
+      prefix = target.is_a?(Network) ? 'N' : 'U'
+      target.at_connect.try(:each) { |line| r "    [#{prefix}] #{line}" }
     end
 
-    def add(args, user)
-      network_name, network, user = NetworkCommand.get_network(args, user)
-      raise(Command::ArgumentError, "No network found") unless network
-      line = args[:rest].join(' ')
-      raise(Command::ArgumentError, "atconnect commands must start with a /") unless line[0] == '/'[0]
-      network.at_connect = network.at_connect + [line]
-      network.save
-      list(args, user, network)
+    def execute
+      if opts['network'].present? # only settable by admins
+        target = Network.first(:conditions => ["name = ? AND user_id IS NULL", opts['network'].downcase])
+      else
+        target = network_user
+      end
+      raise(Command::ArgumentError, "No network found") unless target
+
+      if args.size == 0
+        r "At connect:"
+        list(target)
+      else
+        line = args.join(' ')
+        raise(Command::ArgumentError, "atconnect commands must start with a /") unless line[0] == '/'[0]
+        if opts['remove']
+          target.at_connect = (target.at_connect || []).reject { |l| l == line }
+        else
+          target.at_connect = (target.at_connect || []) + [line]
+        end
+        target.save
+        r "At connect commands modified:"
+        list(target)
+      end
     end
   end
 
-  class NetworkCommand < CRUDCommand
-    register_crud 'network', Host
+  class NetworkCommand < Command
+    register 'network'
 
-    options.set('public', '--public', 'Set new network as public')
-    options.set('username', '--user=username', '-u', 'Create a user-specific network for another user')
+    def self.admin_only?
+      false
+    end
 
-    def list(args, user)
-      r "All networks:"
-      Network.all.each { |m| r "    #{show(m.hosts.first)}" if m.hosts.first }
+    option('remove', '--remove', '-r', "Remove a hostname for a network, or the entire network if no host is given.")
+    option('network', '--name=NETWORK', '-n', "Operate on a different network than the current connection.")
+    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')
+      user_networks = user.reload.try(:networks) || []
+      if user_networks.present? && public_networks.present?
+        r "Public networks are prefixed with [P], user-specific networks with [U]."
+      end
+      (public_networks + user_networks).each do |net|
+        prefix = net.public? ? 'P' : 'U'
+        r "    [#{prefix}] #{show(net)}"
+      end
     end
 
-    def show(host)
-      "#{host.network.name}#{' (public)' if host.network.public?} " + host.network.hosts.map { |h| "[#{h}]" }.join(' ')
+    def show(network)
+      "#{network.name} " + network.hosts.map { |h| "[#{h}]" }.join(' ')
     end
 
-    def self.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
+    def execute
+      # TODO: this got gross
+      if args.empty? && !opts['remove']
+        list
+        return
       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? && !admin_user?(user)
-        raise Command::ArgumentError, "Only admins can modify public networks"
+      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)
+      else
+        target = network_user.try(:network)
+        if target && target.public? && !self.class.admin_user?(user)
+          raise(Command::ArgumentError, "Only admins can modify public networks")
+        end
+        raise(Command::ArgumentError, "No network found") unless target
       end
-      return network_name, network, user
-    end
 
-    def get_network(args, user)
-      self.class.get_network(args, user)
+      uri = ListenCommand.get_uri(args.shift) unless args.empty?
+      addr_args = { :address => uri.host, :port => uri.port, :ssl => (uri.scheme == 'ircs') } if uri
+
+      if opts['remove']
+        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)
+          respond "    #{show(target)}"
+        else
+          target.destroy
+          r "Network #{target.name} removed"
+        end
+      else
+        unless target
+          create_public = (self.class.admin_user?(user) && opts['public'])
+          raise(Command::ArgumentError, "Only public networks can be created without a user") unless create_public || user
+          raise(Command::ArgumentError, "Creating user networks has been disabled by the admins") unless Setting.get('allow_user_networks') == 'true'
+          target = Network.create(:name => opts['network'], :user => (create_public ? nil : user))
+          unless create_public
+            NetworkUser.create(:user => user, :network => target)
+          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
+      end
     end
+  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}"
+  class SettingCommand < Command
+    register 'setting'
+
+    def self.setting_resources(name)
+      @setting_resources ||= YAML.load_file(File.expand_path("../../../resources/setting_descriptions.yml", __FILE__))
+      @setting_resources[name] || {}
+    end
+
+    def execute
+      case args.size
+      when 0
+        r "Settings:"
+        Setting.all.each { |s| r "    #{s}" }
+      when 1
+        setting = Setting.find_by_name(args.first)
+        if setting
+          r(setting.to_s)
+          desc = self.class.setting_resources(setting.name)
+          if desc['help']
+            desc['help'].each_line { |l| r l }
+          end
+        else
+          r("No setting with that name")
+        end
+      when 2
+        setting = Setting.set(args[0], args[1])
+        setting ? r(setting.to_s) : r("No setting with that name")
       else
-        respond "Not found"
+        show_help
       end
     end
+  end
 
-    def attributes(args, user)
-      network_name, network, user = get_network(args, user)
+  class ConnectionsCommand < Command
+    register 'connections'
 
-      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)
+    def execute
+      require 'socket'
+      $tkellem_server.bouncers.each do |k, bouncer|
+        respond "#{bouncer.user.username}@#{bouncer.network.name} (#{bouncer.connected? ? 'connected' : 'connecting'}) #{"since #{bouncer.connected_at}" if bouncer.connected?}"
+        bouncer.active_conns.each do |conn|
+          port, addr = Socket.unpack_sockaddr_in(conn.get_peername)
+          respond "    #{addr} device=#{conn.device_name} since #{conn.connected_at}"
         end
       end
-
-      uri = ListenCommand.get_uri(args)
-      { :network => network, :address => uri.host, :port => uri.port, :ssl => (uri.scheme == 'ircs') }
     end
   end
 end

data/lib/tkellem/tkellem_server.rb

@@ -4,17 +4,26 @@ require 'active_record'
 require 'tkellem/bouncer_connection'
 require 'tkellem/bouncer'
 
-require 'tkellem/models/user'
-require 'tkellem/models/network'
 require 'tkellem/models/host'
-require 'tkellem/models/network_user'
 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/push_service'
 require 'tkellem/plugins/backlog'
+require 'tkellem/plugins/push_service'
 
 module Tkellem
 
+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
+
 class TkellemServer
   include Tkellem::EasyLogger
 
@@ -23,14 +32,7 @@ class TkellemServer
   def initialize
     @listeners = {}
     @bouncers = {}
-
-    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
+    $tkellem_server = self
 
     ListenAddress.all.each { |a| listen(a) }
     NetworkUser.find_each { |nu| add_bouncer(Bouncer.new(nu)) }

data/lib/tkellem/version.rb

@@ -1,3 +1,3 @@
 module Tkellem
-  VERSION = "0.8.6"
+  VERSION = "0.8.7"
 end

data/resources/bot_command_descriptions.yml

@@ -1,36 +1,67 @@
 --- 
 LISTEN:
-  banner: "Usage: LISTEN [--add|--remove|--list] <uri>"
+  banner: "Usage: LISTEN [--remove] <uri>"
   help: |+
+
     Manage the address/port combinations for tkellem to accept client
     connections on.
 
     Protocol is either `irc`, or `ircs` for an SSL listener.
 
-    Example:
-        LISTEN --add ircs://0.0.0.0:10001
+    Examples:
+        LISTEN ircs://0.0.0.0:10001
+        LISTEN --remove ircs://0.0.0.0:10001
 
 USER:
-  banner: "Usage: USER [--add|--remove|--list] <username> [--admin]"
+  banner: "Usage: USER [--remove] <username> [--role=<admin|user>]"
   help: |+
+
     Manage users.
 
     Example:
-        USER --add joe admin
+        USER joe --role=admin
+        USER joe --role=user
+        USER --remove joe
 
 PASSWORD:
-  banner: "Usage: PASSWORD [--user <username>] <new-password>"
+  banner: "Usage: PASSWORD <new-password>"
   help: |+
-    Change password. If you are an admin, you can change other users passwords as well.
+
+    Change password.
 
     Example:
         PASSWORD hunter2
 
 NETWORK:
-  banner: "Usage: NETWORK [--add|--remove|--list] [--public] <network-name> <uri>"
+  banner: "Usage: NETWORK [--remove] [--public] [--name=<network-name>] <uri>"
   help: |+
-    Manage networks. --add will add a new network, or a new connection host to an existing network. Public networks can only be created by admins, and can be joined by anybody.
+
+    Manage networks. Will add a new network, or a new connection host to an existing network. Public networks can only be created by admins, and can be joined by anybody.
+
+    To connect to a network, change the server username in your irc client to reflect what network you want to connect to, in the form of username@network. For instance, to connect to a network called "freenode" as the user "joe", you would set your username to joe@freenode
+
+    Examples:
+        NETWORK ircs://irc.freenode.org:7000 # operate on the current network
+        NETWORK --name=freenode ircs://irc.freenode.org:7000
+        NETWORK --remove --name=freenode ircs://irc.freenode.org:7000
+        NETWORK --remove --name=freenode
+
+ATCONNECT:
+  banner: "Usage: ATCONNECT [--remove] <command>"
+  help: |+
+
+    Add or remove an IRC command to run at connect.
+
+    Examples:
+        ATCONNECT /join #tkellem
+        ATCONNECT --remove /join #tkellem
+
+SETTING:
+  banner: "SETTING [<name>] [<new_value>]"
+  help: |+
+
+    View and modify global settings.
 
     Examples:
-        NETWORK --add --public freenode irc://irc.freenode.org:6667
-        NETWORK --add freenode ircs://irc.freenode.org:7000
+        SETTING
+        SETTING public_registration true

data/resources/setting_descriptions.yml

@@ -0,0 +1,20 @@
+--- 
+user_registration:
+  help: |+
+    Allow new users to register themselves with this instance of tkellem, rather than having to create all users through the tkellem console. Set to 'open' to allow self-registration, 'verified' to allow self-registration but require admin approval before activation, any other value means closed registration.
+
+    If you enable this, you should configure recaptcha as well, see the help for the recaptcha_api_key setting.
+
+    New users will register themselves by connecting to tkellem with a username but no password and no network specified. The tkellem bot will walk them through the process.
+
+recaptcha_api_key:
+  help: |+
+    Configure the recaptcha API key for public registrations. Generate a key by visiting http://www.google.com/recaptcha/mailhide/apikey . Then set this setting to the value 
+
+    <public key>,<private key>
+
+    That is, the public key, then a comma, then the private key. This will protect user self-signups behind a recaptcha check.
+
+allow_user_networks:
+  help: |+
+    If 'true', allow users to create their own networks with the `/tkellem network` command. Otherwise, users can only join admin-created public networks.

data/spec/bouncer_connection_spec.rb

@@ -6,7 +6,8 @@ include Tkellem
 describe BouncerConnection, "connect" do
   before do
     u = User.create(:username => 'speccer')
-    u.set_password!('test123')
+    u.password = 'test123'
+    u.save
     tk = mock(TkellemServer)
     @b = mock(Bouncer)
     tk.should_receive(:find_bouncer).with(u, 'testhost').and_return(@b)

data/spec/irc_server_spec.rb

@@ -14,7 +14,7 @@ describe Bouncer, "connection" do
   end
 
   def send_welcome(s, &just_before_last)
-    s.should_receive(:send_msg).with("USER speccer somehost tkellem :speccer")
+    s.should_receive(:send_msg).with("USER speccer somehost tkellem :speccer@tkellem")
     s.should_receive(:send_msg).with("NICK speccer")
     s.should_receive(:send_msg).with("AWAY :Away")
     s.connection_established(nil)
@@ -35,9 +35,8 @@ describe Bouncer, "connection" do
   it "should connect to the server on creation" do
     s = make_server
     s.connected?.should_not be_true
-    s.should_receive(:send_msg).with("USER speccer somehost tkellem :speccer")
+    s.should_receive(:send_msg).with("USER speccer somehost tkellem :speccer@tkellem")
     s.should_receive(:send_msg).with("NICK speccer")
-    s.should_receive(:send_msg).with("AWAY :Away")
     s.connection_established(nil)
   end
 

metadata

@@ -2,7 +2,7 @@
 name: tkellem
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.8.6
+  version: 0.8.7
 platform: ruby
 authors: 
 - Brian Palmer
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-18 00:00:00 -06:00
+date: 2011-06-20 00:00:00 -06:00
 default_executable: tkellem
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -137,18 +137,22 @@ files:
 - lib/tkellem/irc_server.rb
 - lib/tkellem/migrations/001_init_db.rb
 - lib/tkellem/migrations/002_at_connect_columns.rb
+- lib/tkellem/migrations/003_settings.rb
 - lib/tkellem/models/host.rb
 - lib/tkellem/models/listen_address.rb
 - lib/tkellem/models/network.rb
 - lib/tkellem/models/network_user.rb
+- lib/tkellem/models/setting.rb
 - lib/tkellem/models/user.rb
 - lib/tkellem/plugins/backlog.rb
 - lib/tkellem/plugins/push_service.rb
+- lib/tkellem/plugins/recaptcha.rb
 - lib/tkellem/socket_server.rb
 - lib/tkellem/tkellem_bot.rb
 - lib/tkellem/tkellem_server.rb
 - lib/tkellem/version.rb
 - resources/bot_command_descriptions.yml
+- resources/setting_descriptions.yml
 - spec/bouncer_connection_spec.rb
 - spec/irc_message_spec.rb
 - spec/irc_server_spec.rb