fargo 0.1.1 → 0.2.0

data/lib/fargo/search_result.rb

@@ -15,17 +15,17 @@ module Fargo
       end
 
       s << sprintf(" %d/%d\005%s (%s:%d)", @client.open_slots,
-                                           @client.slots,
+                                           @client.config.upload_slots,
                                            @client.hub.hubname,
-                                           @client.hub.config.ip,
-                                           @client.hub.config.port)
+                                           @client.config.hub_address,
+                                           @client.config.hub_port)
       s << "\005#{@target}" if @client.config.passive
     end
 
     def active_send nick, ip, port
-      socket = UDPSocket.new
-      socket.send "$SR #{nick} #{to_s}", 0, ip, port
-      socket.close
+      socket = EventMachine.open_datagram_socket '0.0.0.0', 0
+      socket.send_datagram "$SR #{nick} #{to_s}", ip, port
+      socket.close_connection_after_writing
     end
   end
 end

data/lib/fargo/supports/chat.rb

@@ -2,9 +2,9 @@ module Fargo
   module Supports
     module Chat
       extend ActiveSupport::Concern
-      
+
       included do
-        set_callback :setup, :after, :subscribe_to_chats
+        set_callback :initialization, :after, :initialize_chats
       end
 
       def messages
@@ -12,14 +12,16 @@ module Fargo
       end
 
       def messages_with nick
-        @chats[nick] if @chats
+        @chats[nick]
       end
 
-      def subscribe_to_chats
+      protected
+
+      def initialize_chats
         @public_chats = []
-        @chats = Hash.new{ |h, k| h[k] = [] }
+        @chats        = Hash.new{ |h, k| h[k] = [] }
 
-        subscribe do |type, map|
+        channel.subscribe do |type, map|
           if type == :chat
             @public_chats << map
           elsif type == :privmsg
@@ -30,6 +32,7 @@ module Fargo
           end
         end
       end
+
     end
   end
-end
+end

data/lib/fargo/supports/downloads.rb

@@ -11,12 +11,15 @@ module Fargo
         end
       end
 
+      included do
+        set_callback :initialization, :after, :initialize_download_lists
+      end
+
       attr_reader :current_downloads, :finished_downloads, :queued_downloads,
-                  :failed_downloads, :open_download_slots, :trying, :timed_out,
-                  :download_slots
+                  :failed_downloads, :trying, :timed_out
 
-      included do
-        set_callback :setup, :after, :initialize_queues
+      def has_download_slot?
+        @current_downloads.size + @trying.size < config.download_slots
       end
 
       def clear_failed_downloads
@@ -56,34 +59,45 @@ module Fargo
         download.percent = 0
         download.status  = 'idle'
 
-        # Append it to the queue of things to download. This will be processed
-        # elsewhere
-        @to_download << download
+        # Using the mutex can be expensive in start_download, defer this
+        if @timed_out.include? download.nick
+          download.status = 'timeout'
+          @failed_downloads[download.nick] << download
+        else
+          unless @queued_downloads[download.nick].include?(download) ||
+              @current_downloads[download.nick] == download
+            @queued_downloads[download.nick] << download
+
+            # This uses the lock and could be expensive, defer this for later
+            EventMachine.defer{ start_download }
+          end
+        end
+
         true
       end
 
       def retry_download nick, file
-        dl = (@failed_downloads[nick] ||= []).detect{ |h| h.file == file }
+        dl = @failed_downloads[nick].detect{ |h| h.file == file }
 
-        if dl.nil?
-          Fargo.logger.warn "#{file} isn't a failed download for: #{nick}!"
-          return
-        end
+        return if dl.nil?
 
         @failed_downloads[nick].delete dl
-        download dl.nick, dl.file, dl.tth, dl.size
+        download dl
       end
 
       def remove_download nick, file
         # We need to synchronize this access, so append these arguments to a
         # queue to be processed later
-        @to_remove << [nick, file]
-        true
+        EventMachine.defer do
+          @downloading_lock.synchronize {
+            @queued_downloads[nick].delete_if{ |h| h.file == file }
+          }
+        end
       end
 
       def lock_next_download! user, connection
         @downloading_lock.synchronize {
-          return get_next_download_with_lock! user, connection
+          get_next_download_with_lock! user, connection
         }
       end
 
@@ -94,16 +108,17 @@ module Fargo
         @timed_out.delete nick
         downloads = @failed_downloads[nick].dup
         @failed_downloads[nick].clear
+        # Reschedule all the failed downloads again
         downloads.each{ |d| download nick, d.file, d.tth, d.size }
 
         true
       end
 
-      private
+      protected
 
       # Finds the next queued up download and begins downloading it.
       def start_download
-        return false if open_download_slots == 0 || @current_downloads.size + @trying.size > download_slots
+        return false unless has_download_slot?
 
         arr = nil
 
@@ -114,7 +129,7 @@ module Fargo
               !@current_downloads.has_key?(nick) &&
               !@trying.include?(nick) &&
               !@timed_out.include?(nick) &&
-              (connection_for(nick) || has_slot?(nick))
+              (connection_for(nick) || nick_has_slot?(nick))
           }
 
           return false if arr.nil? || arr.size == 0
@@ -127,6 +142,7 @@ module Fargo
           if connection
             Fargo.logger.debug "Requesting previous connection downloads: #{arr[1].first}"
             download = get_next_download_with_lock! dl_nick, connection
+
             connection.download = download
             connection.begin_download!
           else
@@ -135,18 +151,14 @@ module Fargo
             connect_with dl_nick
           end
         }
-
-        arr
       end
 
       # This method should only be called when synchronized by the mutex
       def get_next_download_with_lock! user, connection
-        raise 'No open slots!'                    if @open_download_slots <= 0
+        raise 'No open slots!'                    unless has_download_slot?
         raise "Already downloading from #{user}!" if @current_downloads[user]
 
-        if @queued_downloads[user].nil? || @queued_downloads[user].size == 0
-          return nil
-        end
+        return nil if @queued_downloads[user].size == 0
 
         download                 = @queued_downloads[user].shift
         @current_downloads[user] = download
@@ -154,26 +166,24 @@ module Fargo
 
         Fargo.logger.debug "#{self}: Locking download: #{download}"
 
-        block = Proc.new{ |type, map|
-          Fargo.logger.debug "#{connection}: received: #{type.inspect} - #{map.inspect}"
-
-          if type == :download_progress
-            download.percent = map[:percent]
-          elsif type == :download_started
-            download.status = 'downloading'
-          elsif type == :download_finished
-            connection.unsubscribe &block
-            download.percent = 1
-            download.status = 'finished'
-            download_finished! user, false
-          elsif type == :download_failed || type == :download_disconnected
-            connection.unsubscribe &block
-            download.status = 'failed'
-            download_finished! user, true
+        subscribed_id = channel.subscribe do |type, map|
+          if map[:nick] == user
+            if type == :download_progress
+              download.percent = map[:percent]
+            elsif type == :download_started
+              download.status = 'downloading'
+            elsif type == :download_finished
+              channel.unsubscribe subscribed_id
+              download.percent = 1
+              download.status  = 'finished'
+              download_finished! user, false
+            elsif type == :download_failed || type == :download_disconnected
+              channel.unsubscribe subscribed_id
+              download.status = 'failed'
+              download_finished! user, true
+            end
           end
-        }
-
-        connection.subscribe &block
+        end
 
         download
       end
@@ -182,104 +192,50 @@ module Fargo
         download = nil
         @downloading_lock.synchronize{
           download = @current_downloads.delete user
-          @open_download_slots += 1
-
-          # connection_for(user).disconnect if @queued_downloads[user].size == 0
         }
 
         if failed
-          (@failed_downloads[user] ||= []) << download
+          @failed_downloads[user] << download
         else
-          (@finished_downloads[user] ||= []) << download
+          @finished_downloads[user] << download
         end
 
-        start_download # Start another download if possible
+        # Start another download if possible
+        EventMachine.defer{ start_download }
       end
 
       def connection_failed_with! nick
-        @trying.delete nick
-        @timed_out << nick
-
         @downloading_lock.synchronize {
+          @trying.delete nick
+          @timed_out << nick
+
           @queued_downloads[nick].each{ |d| d.status = 'timeout' }
-          @failed_downloads[nick] ||= []
-          @failed_downloads[nick] = @failed_downloads[nick] | @queued_downloads[nick]
-          @queued_downloads[nick].clear
+          @failed_downloads[nick] |= @queued_downloads.delete(nick)
         }
 
-        start_download # This one failed, try the next one
+        # This one failed, try the next one
+        EventMachine.defer{ start_download }
       end
 
-      def initialize_queues
-        @download_slots ||= 4
-
+      def initialize_download_lists
         FileUtils.mkdir_p config.download_dir, :mode => 0755
 
         @downloading_lock = Mutex.new
 
-        # Don't use Hash.new{} because this can't be dumped by Marshal
-        @queued_downloads   = {}
+        @queued_downloads   = Hash.new{ |h, k| h[k] = [] }
         @current_downloads  = {}
-        @failed_downloads   = {}
-        @finished_downloads = {}
+        @failed_downloads   = Hash.new{ |h, k| h[k] = [] }
+        @finished_downloads = Hash.new{ |h, k| h[k] = [] }
         @trying             = []
         @timed_out          = []
 
-        @open_download_slots = download_slots
-
-        subscribe { |type, hash|
+        channel.subscribe do |type, hash|
           if type == :connection_timeout
             connection_failed_with! hash[:nick] if @trying.include?(hash[:nick])
-          elsif type == :hub_disconnected
-            exit_download_queue_threads
-          elsif type == :hub_connection_opened
-            start_download_queue_threads
           end
-        }
-      end
-
-      def exit_download_queue_threads
-        @download_starter_thread.exit
-        @download_removal_thread.exit
-      end
-
-      # Both of these need access to the synchronization lock, so we use
-      # separate threads to do these processes.
-      def start_download_queue_threads
-        @to_download = Queue.new
-        @download_starter_thread = Thread.start {
-          loop {
-            download = @to_download.pop
-
-            if @timed_out.include? download.nick
-              download.status = 'timeout'
-              (@failed_downloads[download.nick] ||= []) << download
-            else
-              @queued_downloads[download.nick] ||= []
-
-              unless @queued_downloads[download.nick].include?(download) ||
-                  @current_downloads[download.nick] == download
-                @queued_downloads[download.nick] << download
-                start_download
-              end
-            end
-          }
-        }
-
-        @to_remove = Queue.new
-        @download_removal_thread = Thread.start {
-          loop {
-            user, file = @to_remove.pop
-
-            @downloading_lock.synchronize {
-              @queued_downloads[user] ||= []
-              download = @queued_downloads[user].detect{ |h| h.file == file }
-              @queued_downloads[user].delete download unless download.nil?
-            }
-          }
-        }
+        end
       end
 
-    end # Downloads
-  end # Supports
-end # Fargo
+    end
+  end
+end

data/lib/fargo/supports/file_list.rb

@@ -6,31 +6,35 @@ module Fargo
     module FileList
       class Listing < Struct.new(:tth, :size, :name, :nick); end
 
+      extend ActiveSupport::Concern
+
+      included do
+        set_callback :initialization, :after, :initialize_file_lists
+      end
+
       # Lazily load the file list for the nick. Subscribe to the client for the
       # event :file_list to get notified.
       def file_list nick
-        @file_list ||= {}
-        @getting_file_list ||= {}
-
         if @file_list.has_key?(nick)
           return parse_file_list(@file_list[nick], nick)
         elsif @getting_file_list[nick]
           return true
         end
 
-        file_gotten = lambda{ |type, map|
+        subscription_id = channel.subscribe do |type, map|
           case type
             when :download_finished, :download_failed, :connection_timeout
               if map[:nick] == nick
                 @file_list[nick] = map[:file]
-                unsubscribe &file_gotten
-                publish :file_list, :nick => nick, :list => @file_list[nick]
+
+                channel.unsubscribe subscription_id
+                channel << [:file_list,
+                    {:nick => nick, :list => @file_list[nick]}]
+
                 @getting_file_list.delete nick
               end
           end
-        }
-
-        subscribe &file_gotten
+        end
 
         @getting_file_list[nick] = true
         download nick, 'files.xml.bz2'
@@ -38,7 +42,6 @@ module Fargo
 
       # Wait for the results to arrive, timed out after some time
       def file_list! nick, timeout = 10
-        @file_list ||= {}
         if @file_list.has_key?(nick)
           return parse_file_list(@file_list[nick], nick)
         end
@@ -91,6 +94,14 @@ module Fargo
 
         list
       end
+
+      protected
+
+      def initialize_file_lists
+        @file_list = {}
+        @getting_file_list = {}
+      end
+
     end
   end
 end

data/lib/fargo/supports/nick_list.rb

@@ -2,31 +2,38 @@ module Fargo
   module Supports
     module NickList
       extend ActiveSupport::Concern
-      
+
       included do
-        set_callback :setup, :after, :subscribe_to_nicks
+        set_callback :initialization, :after, :initialize_nick_lists
       end
-      
+
       attr_accessor :nicks
-      
+
+      def get_info nick
+        hub.send_message 'GetINFO', "#{nick} #{config.nick}"
+      end
+
+      def get_ip *nicks
+        hub.send_message 'UserIP', nicks.flatten.join('$$')
+      end
+
       def info nick
-        return nil unless @nick_info
         if @nick_info.has_key?(nick) || !connected? || !@nicks.include?(nick)
-          return @nick_info[nick] 
+          return @nick_info[nick]
         end
 
         # If we're connected and we don't already have this user's info, ask the
         # server. We'll wait for 5 second to respond, otherwise we'll just
         # return nil and be done with it
-        info_gotten = lambda{ |type, map| 
-          map[:type] == :myinfo && map[:nick].to_s == nick.to_s
+        info_gotten = lambda{ |type, map|
+          type == :myinfo && map[:nick].to_s == nick.to_s
         }
         timeout_response(5, info_gotten){ get_info nick }
 
         @nick_info[nick]
       end
-      
-      def has_slot? nick
+
+      def nick_has_slot? nick
         # This query must be up to date so remove any cached information we have
         # about the nick so we can get a fresh copy
         @nick_info.try :delete, nick
@@ -41,12 +48,14 @@ module Fargo
         Fargo.logger.debug "#{self} User: #{nick} has #{match[1]} open slots"
         match[1].to_i > 0
       end
-      
-      def subscribe_to_nicks
+
+      protected
+
+      def initialize_nick_lists
         @nicks     = []
         @nick_info = Hash.new{ |h, k| h[k] = {} }
 
-        subscribe do |type, map|
+        channel.subscribe do |type, map|
           case type
             when :hello
               @nicks << map[:who] unless @nicks.include? map[:who]
@@ -65,7 +74,7 @@ module Fargo
           end
         end
       end
-    
+
     end
   end
 end

data/lib/fargo/supports/persistence.rb

@@ -4,50 +4,55 @@ module Fargo
       extend ActiveSupport::Concern
 
       included do
-        set_callback :setup, :after, :setup_connection_cache
+        set_callback :initialization, :after, :initialize_connection_caches
       end
 
-      def lock_connection_with! nick, connection
-        @connection_cache[nick] = connection
-      end
+      def connect_with nick
+        @connection_timeouts[nick] = EventMachine::Timer.new(10) do
+          @connection_timeouts.delete(nick)
+          channel.push [:connection_timeout, {:nick => nick}]
+        end
 
-      def connection_for nick
-        c = @connection_cache.try :[], nick
-        if c.nil? || c.connected?
-          Fargo.logger.debug "#{self} has connection with: #{nick}: #{c}"
-          return c
+        if config.passive
+          hub.send_message 'RevConnectToMe', "#{self.config.nick} #{nick}"
+        else
+          hub.send_message 'ConnectToMe',
+            "#{nick} #{config.address}:#{config.active_port}"
         end
+      end
 
-        # If it's present and not connected, remove it from the cache
-        @connection_cache.try :delete, nick
-        nil
+      def connection_for nick
+        @connection_cache[nick]
       end
 
       def connected_with? nick
-        c = @connection_cache.try :[], nick
-        c.connected? unless c.nil?
+        @connection_cache.has_key? nick
       end
 
       def disconnect_from nick
-        c = @connection_cache.try :delete, nick
-        c.disconnect unless c.nil?
+        c = @connection_cache.delete nick
+        c.try :close_connection_after_writing
       end
 
       def nicks_connected_with
-        return [] if @connection_cache.nil?
-
-        nicks = @connection_cache.keys
-        nicks.reject{ |n| !connected_with? n }
+        @connection_cache.keys
       end
 
-      def setup_connection_cache
+      protected
+
+      def initialize_connection_caches
         @connection_cache = {}
 
-        subscribe { |type, hash|
+        channel.subscribe do |type, hash|
           if type == :hub_disconnected
             nicks_connected_with.each{ |n| disconnect_from n }
+          elsif type == :download_disconnected
+            @connection_cache.delete hash[:nick]
+          elsif type == :download_opened
+            @connection_timeouts.delete(hash[:nick]).try(:cancel)
+            @connection_cache[hash[:nick]] = hash[:connection]
           end
-        }
+        end
       end
 
     end

data/lib/fargo/supports/searches.rb

@@ -2,9 +2,30 @@ module Fargo
   module Supports
     module Searches
       extend ActiveSupport::Concern
-      
+
       included do
-        set_callback :setup, :after, :subscribe_to_searches
+        set_callback :initialization, :after, :initialize_search_caches
+      end
+
+      # see parser#@@search for what's passed in
+      #
+      # searches this client's files based on those options and returns an array
+      # of SearchResult(s)
+      def search_files options
+        # TODO: implement me
+        []
+      end
+
+      def search_hub query
+        raise ConnectionError.new('Not connected Yet!') unless connected?
+
+        if config.passive
+          location = "Hub:#{config.nick}"
+        else
+          location = "#{config.address}:#{config.search_port}"
+        end
+
+        hub.send_message 'Search', "#{location} #{query.to_s}"
       end
 
       def search search
@@ -17,21 +38,21 @@ module Fargo
       end
 
       def searches
-        @searches.keys.map { |k| @search_objects[k] } if @searches
+        @searches.keys.map { |k| @search_objects[k] }
       end
 
       def search_results search
         search = normalize search
-        @searches[search.to_s] if @searches
+        @searches[search.to_s]
       end
 
       def remove_search search
         search = normalize search
-        @searches.delete search.to_s if @searches
-        @search_objects.delete search.to_s if @search_objects
+        @searches.delete search.to_s
+        @search_objects.delete search.to_s
       end
 
-      private
+      protected
 
       def normalize search
         unless search.is_a? Fargo::Search
@@ -41,11 +62,11 @@ module Fargo
         search
       end
 
-      def subscribe_to_searches
+      def initialize_search_caches
         @searches       = {}
         @search_objects = {}
 
-        subscribe do |type, map|
+        channel.subscribe do |type, map|
           if type == :search_result
             @searches.keys.each do |search|
               if @search_objects[search].matches_result?(map)