vetinari 0.0.1

data/lib/vetinari/channel.rb

@@ -0,0 +1,249 @@
+module Vetinari
+  # Data structure which is used for storing users:
+  # {lower_cased_nick => {User => [modes]}}
+  #
+  # Example:
+  # {'ponder' => {:user => #<User nick="Ponder">, :modes => ['v', 'o']}}
+  #
+  # TODO: Actor?
+  class Channel
+    attr_reader :name, :users, :users_with_modes, :modes, :lists
+
+    def initialize(name, bot)
+      @name = name
+      @bot = bot
+      @users = Set.new
+      @users_with_modes = {}
+      @modes = {}
+      @lists = Hash.new { |hash, key| hash[key] = [] }
+      @mutex = Mutex.new
+    end
+
+    # Experimental, no tests so far.
+    # def topic
+    #   if @topic
+    #     @topic
+    #   else
+    #     connected do
+    #       fiber = Fiber.current
+    #       callbacks = {}
+    #       [331, 332, 403, 442].each do |numeric|
+    #         callbacks[numeric] = @thaum.on(numeric) do |event_data|
+    #           topic = event_data[:params].match(':(.*)').captures.first
+    #           fiber.resume topic
+    #         end
+    #       end
+
+    #       @bot.raw "TOPIC #{@name}"
+    #       @topic = Fiber.yield
+    #       callbacks.each do |type, callback|
+    #         @thaum.callbacks[type].delete(callback)
+    #       end
+
+    #       @topic
+    #     end
+    #   end
+    # end
+
+    def topic=(topic)
+      @bot.raw "TOPIC #{@name} :#{topic}"
+    end
+
+    def ban(hostmask)
+      mode '+b', hostmask
+    end
+
+    def unban(hostmask)
+      mode '-b', hostmask
+    end
+
+    def lock(key)
+      @bot.raw "MODE #{@name} +k #{key}"
+    end
+
+    def unlock
+      key = @modes['k']
+      @bot.raw "MODE #{@name} -k #{key}" if key
+    end
+
+    def kick(user, reason = nil)
+      if reason
+        @bot.raw "KICK #{@name} #{user.nick} :#{reason}"
+      else
+        @bot.raw "KICK #{@name} #{user.nick}"
+      end
+    end
+
+    def invite(user)
+      @bot.raw "INVITE #{@name} #{user.nick}"
+    end
+
+    def op(user)
+      mode '+o', user.nick
+    end
+
+    def deop(user)
+      mode '-o', user.nick
+    end
+
+    def voice(user_or_nick)
+      mode '+v', user.nick
+    end
+
+    def devoice(user_or_nick)
+      mode '-v', user.nick
+    end
+
+    def join(key = nil)
+      if key
+        @bot.raw "JOIN #{@name} #{key}"
+      else
+        @bot.raw "JOIN #{@name}"
+      end
+    end
+
+    def part(message = nil)
+      if message
+        @bot.raw "PART #{@name} :#{message}"
+      else
+        @bot.raw "PART #{@name}"
+      end
+    end
+
+    def hop(message = nil)
+      key = @modes['k']
+      part message
+      join key
+    end
+
+    def add_user(user, modes = [])
+      @mutex.synchronize do
+        @users << user
+        @users_with_modes[user] = modes
+      end
+    end
+
+    def remove_user(user)
+      @mutex.synchronize do
+        @users_with_modes.delete(user)
+        @users.delete?(user) ? user : nil
+      end
+    end
+
+    def has_user?(user)
+      @users.include?(user)
+    end
+
+    # def find_user(user)
+    #   case user_or_nick
+    #   when String
+    #     @users.find { |u| u.nick.downcase == user_or_nick.downcase }
+    #   when User
+    #     has_user?(user_or_nick) ? user_or_nick : nil
+    #   end
+    # end
+
+    # def find_user_with_modes(user_or_nick)
+    #   user = case user_or_nick
+    #   when String
+    #     @users.find { |u| u.nick.downcase == user_or_nick.downcase }
+    #   when User
+    #     has_user?(user_or_nick) ? user_or_nick : nil
+    #   end
+
+    #   {:user => user, :modes => @users_with_modes[user]} if user
+    # end
+
+    def modes_of(user)
+      @users_with_modes[user] if has_user?(user)
+    end
+
+    # TODO
+    def set_mode(mode, isupport)
+      if isupport['PREFIX'].keys.include?(mode[:mode])
+        user = find_user(mode[:param])
+        if user
+          case mode[:direction]
+          when :'+'
+            @users_with_modes[user] << mode[:mode]
+          when :'-'
+            @users_with_modes[user].delete(mode[:mode])
+          end
+        end
+      elsif isupport['CHANMODES']['A'].include?(mode[:mode])
+        case mode[:direction]
+        when :'+'
+          add_to_list(mode[:mode], mode[:param])
+        when :'-'
+          remove_from_list(mode[:mode], mode[:param])
+        end
+      elsif isupport['CHANMODES']['B'].include?(mode[:mode])
+        case mode[:direction]
+        when :'+'
+          set_channel_mode(mode[:mode], mode[:param])
+        when :'-'
+          unset_channel_mode(mode[:mode])
+        end
+      elsif isupport['CHANMODES']['C'].include?(mode[:mode])
+        case mode[:direction] 
+        when :'+'
+          set_channel_mode(mode[:mode], mode[:param])
+        when :'-'
+          unset_channel_mode(mode[:mode])
+        end
+      elsif isupport['CHANMODES']['D'].include?(mode[:mode])
+        case mode[:direction] 
+        when :'+'
+          set_channel_mode(mode[:mode], true)
+        when :'-'
+          unset_channel_mode(mode[:mode])
+        end
+      end
+    end
+
+    def mode(modes, params = nil)
+      if params
+        @bot.raw "MODE #{@name} #{modes} #{params}"
+      else
+        @bot.raw "MODE #{@name} #{modes}"
+      end
+    end
+
+    def get_mode
+      @bot.raw "MODE #{@name}"
+    end
+
+    def message(message)
+      @bot.raw "PRIVMSG #{@name} :#{message}"
+    end
+
+    def inspect
+      "#<Channel name=#{@name.inspect}>"
+    end
+
+    private
+
+    def set_channel_mode(mode, param)
+      @modes[mode] = param
+    end
+
+    def unset_channel_mode(mode)
+      @modes.delete(mode)
+    end
+
+    def add_to_list(list, param)
+      @mutex.synchronize do
+        @lists[list] ||= []
+        @lists[list] << param
+      end
+    end
+
+    def remove_from_list(list, param)
+      @mutex.synchronize do
+        if @lists[list].include?(param)
+          @lists[list].delete(param)
+        end
+      end
+    end
+  end
+end

data/lib/vetinari/channel_container.rb

@@ -0,0 +1,74 @@
+module Vetinari
+  class ChannelContainer
+    include Celluloid
+
+    attr_reader :channels
+
+    exclusive
+
+    def initialize
+      @channels = Set.new
+    end
+
+    def add(channel)
+      @channels << channel
+    end
+
+    def [](channel_or_channel_name)
+      case channel_or_channel_name
+      when Channel
+        if @channels.include?(channel_or_channel_name)
+          channel_or_channel_name
+        end
+      when String
+        @channels.find do |c|
+          c.name.downcase == channel_or_channel_name.downcase
+        end
+      end
+    end
+
+    def has_channel?(channel)
+      self[channel] ? true : false
+    end
+
+    def remove(channel)
+      if has_channel?(channel)
+        @channels.delete(channel)
+      end
+    end
+
+    # Removes a User from all Channels from the ChannelList.
+    # Returning a Set of Channels in which the User was.
+    def remove_user(user)
+      channels = Set.new
+
+      @channels.each do |channel|
+        if channel.remove_user(user)
+          channels << channel
+        end
+      end
+
+      channels
+    end
+
+    # Removes all Channels from the ChannelList and returns them.
+    def clear
+      channels = @channels.dup
+      @channels.clear
+      channels
+    end
+
+    # Returns a Set of all Users that are in one of the Channels from the
+    # ChannelList.
+    # TODO: Refactor
+    def users
+      users = Set.new
+
+      @channels.each do |channel|
+        users.merge(channel.users)
+      end
+
+      users
+    end
+  end
+end

data/lib/vetinari/configuration.rb

@@ -0,0 +1,54 @@
+module Vetinari
+  class Configuration < OpenStruct
+    def initialize(&block)
+      super
+      self.server             = 'chat.freenode.org'
+      self.port               = 6667
+      self.ssl                = false
+      self.nick               = "Vetinari#{rand(10_000)}"
+      self.username           = 'Vetinari'
+      self.real_name          = 'Havelock Vetinari'
+      self.verbose            = true
+      self.logging            = false
+      self.logger             = nil
+      self.reconnect          = true
+      self.reconnect_interval = 10
+      self.hide_ping_pongs    = true
+      self.rejoin_after_kick  = false
+      self.password           = nil
+
+      self.isupport  = ISupport.new
+      self.dcc       = OpenStruct.new
+      self.dcc.ports = []
+
+      block.call(self) if block_given?
+      setup_loggers
+    end
+
+    private
+
+    def setup_loggers
+      self.console_logger = if self.verbose
+        Logging::Logger.new($stdout)
+      else
+        Logging::NullLogger.new
+      end
+
+      self.logger = if self.logging
+        if self.logger
+          self.logger
+        else
+          log_path = File.join($0, 'logs', 'log.log')
+          log_dir = File.dirname(log_path)
+          FileUtils.mkdir_p(log_dir) unless File.exist?(log_dir)
+          Logging::Logger.new(log_path, File::WRONLY | File::APPEND)
+        end
+      else
+        Logging::NullLogger.new
+      end
+
+      self.loggers = Logging::LoggerList.new
+      self.loggers.push(self.console_logger, self.logger)
+    end
+  end
+end

data/lib/vetinari/dcc/incoming/file.rb

@@ -0,0 +1,113 @@
+module Vetinari
+  module Dcc
+    module Incoming
+      class File
+        include Celluloid::IO, Celluloid::Notifications
+
+        attr_reader :user, :filename, :ip, :port, :filesize, :state
+
+        def initialize(user, filename, ip, port, filesize, bot)
+          @user       = user
+          @filename   = filename
+          @ip         = ip
+          @port       = port
+          @filesize   = filesize
+          @bot        = bot
+          @mutex      = Mutex.new
+          
+          self.state = :pending
+        end
+
+        def accept(directory = '~/Downloads/', resume = false)
+          if @state == :pending
+            self.state = :accepted
+            directory = ::File.expand_path(directory)
+            @filepath = ::File.join(directory, @filename)
+
+            if resume && resumable?
+              resume_transfer
+            else
+              download
+            end
+          end
+        end
+
+        def inspect
+          "#<File filename=#{@filename} filesize=#{@filesize} user=#{@user.inspect}"
+        end
+
+        def resume_accepted(position)
+          self.state = :resume_accepted
+          download(position)
+        end
+
+        def state=(state)
+          old_state = @state
+          @state = state
+          publish('vetinari.dcc.incoming.file', Actor.current, old_state, @state)
+        end
+
+        private
+
+        def download(position = 0)
+          self.state = :connecting
+
+          begin
+            @socket = TCPSocket.new(@ip.to_s, @port)
+            self.state = :connected
+          rescue Errno::ECONNREFUSED
+            self.state = :failed
+            return
+          end
+
+          file_mode = position > 0 ? 'a' : 'w'
+
+          begin
+            ::File.open(@filepath, file_mode) do |file|
+              self.state = :downloading
+
+              while buffer = @socket.readpartial(8192)
+                position += buffer.bytesize
+                file.write(buffer)
+                break if position >= @filesize
+              end
+            end
+
+            self.state = :finished
+          rescue EOFError
+            self.state = :aborted
+          ensure
+            @socket.close
+          end
+        ensure
+          return self
+        end
+
+        def resumable?
+          ::File.file?(@filepath) && ::File.size(@filepath) <= @filesize
+        end
+
+        def resume_transfer
+          self.state = :resuming
+          filename = Regexp.escape(@filename)
+          position = ::File.size(@filepath)
+          file = Actor.current
+
+          cb = @bot.on(:query, /\A\001DCC ACCEPT \"?#{filename}\"? #{@port} #{position}\001\z/, 1) do |env|
+            file.async.resume_accepted(position)
+            cb.async.remove
+          end
+
+          @user.message("\001DCC RESUME \"#{@filename}\" #{@port} #{position}\001")
+
+          after(30) do
+            if @state == :resuming
+              cb.remove
+              file.state = :resume_not_accepted
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vetinari/dcc/server.rb

@@ -0,0 +1,107 @@
+module Vetinari
+  module Dcc
+    class Server
+      include Celluloid
+
+      attr_reader :user, :filepath, :state
+
+      def initialize(user, filepath, filename, server_manager)
+        @user = user
+        @filepath = filepath
+        @filename = filename
+        @server_manager = server_manager
+        @state = :idling
+      end
+
+      def run(port)
+        @port = port
+        register_resume_callback
+        start
+      end
+
+      def inspect
+        "#<Server @user=#{@user.inspect} @filepath=#{filepath}"
+      end
+
+      private
+
+      def start
+        @thread = Thread.new do
+          begin
+            int_ip = IPAddr.new(@server_manager.external_ip).to_i
+            @socket = TCPServer.new(@server_manager.internal_ip, @port)
+            @state = :running
+            @user.message("\001DCC SEND \"#{@filename}\" #{int_ip} #{@port} #{File.size(@filepath)}\001")
+            @client = @socket.accept
+            @state = :sending
+
+            File.open(@filepath, 'rb') do |file|
+              file.seek(@position) if @position
+
+              while buffer = file.read(8096)
+                @client.write(buffer)
+              end
+            end
+
+            # Clients like mIRC want to close the connection
+            # client side. Else the transfer will count as
+            # failed. So, give the client a second to close.
+            sleep 1
+          rescue StandardError => e
+            p e.message
+          ensure
+            # binding.pry
+            async.stop
+          end
+        end
+
+        after(5) do
+          p 'TIMMERERRRRRRRRRRRRRRRRRRRRR'
+          if @state == :running
+            async.stop(:timeout)
+            p :async_stop
+          end
+        end
+      end
+
+      def stop(state = :stopped)
+        p 'SERVER STOPPED'
+        @state = state
+        @client.close rescue nil
+        @socket.close rescue nil
+        remove_resume_callback
+        start_next
+      end
+
+      def start_next
+        @server_manager.release_port(@port)
+        p 'release port'
+        @server_manager.async.start_sending
+        p 'start sending'
+      end
+
+      def register_resume_callback
+        @resume_callback = @server_manager.bot.on(:query, /\A\001DCC RESUME \"#{Regexp.escape(@filename)}\" #{@port} \d+\001\z/, 1) do |env|
+          if @state == :running
+            position = begin
+              result = env[:message].scan(/\A\001DCC RESUME \"#{Regexp.escape(@filename)}\" #{@port} (\d+)\001\z/)
+              Integer(result.first.first)
+            rescue
+              0
+            end
+          
+            if position > 0 && position < File.size(@filepath)
+              @position = position
+              @user.message("\001DCC ACCEPT \"#{@filename}\" #{@port} #{@position}")
+              remove_resume_callback
+            end
+          end
+        end
+      end
+
+      def remove_resume_callback
+        @resume_callback.async.remove
+      end
+    end
+  end
+end

data/lib/vetinari/dcc/server_manager.rb

@@ -0,0 +1,83 @@
+module Vetinari
+  module Dcc
+    class ServerManager
+      include Celluloid
+
+      attr_reader :bot, :internal_ip, :external_ip
+
+      def initialize(bot)
+        @bot = bot
+        @external_ip = @bot.config.dcc.external_ip
+
+        ip = Socket.ip_address_list.detect { |i| i.ipv4_private? }
+        @internal_ip = ip ? ip.ip_address : '0.0.0.0'
+
+        @ports = @bot.config.dcc.ports
+        @queue = []
+        @mutex = Mutex.new
+        @running_servers = {} # {port => #<Vetinari::Dcc::Server>}
+      end
+
+      def add_offering(user, filepath, filename)
+        server = Server.new(user, filepath, filename, Actor.current)
+        @mutex.synchronize { @queue << server }
+        async.start_sending
+        server
+      end
+
+      def start_sending
+        @mutex.synchronize do
+          if @queue.any?
+            port = get_available_port
+
+            if port
+              server = @queue.pop
+              server.async.run(port)
+              @running_servers[port] = server
+            else
+              # There are items in the queue but for some reasons no ports are
+              # available. Try again later.
+              after(3) { start_sending }
+            end
+          end
+        end
+      end
+
+      def release_port(port)
+        @mutex.synchronize do
+          @running_servers.delete(port)
+        end
+      end
+
+      # def find_server(user, filename, port)
+      #   server = @running_servers[port]
+
+      #   if server && server.user == user && server.filename == filename
+      #   end
+      # end
+
+      private
+
+      def get_available_port
+        (@ports - @running_servers.keys).shuffle.each do |port|
+          return port if port_available?(port)
+        end
+
+        nil
+      end
+
+      def port_available?(port)
+        Timeout::timeout(3) do
+          begin
+            TCPServer.new(port).close
+            true
+          rescue Errno::EADDRINUSE
+            false
+          end
+        end
+      rescue Timeout::Error
+        false
+      end
+    end
+  end
+end