fargo 0.1.1 → 0.2.0

data/lib/fargo/client.rb

@@ -1,16 +1,15 @@
-require 'active_support/callbacks'
-require 'active_support/configurable'
+require 'socket'
 require 'active_support/core_ext/object/try'
+require 'active_support/callbacks'
 
 module Fargo
   class Client
 
-    include ActiveSupport::Callbacks
     include ActiveSupport::Configurable
+    include ActiveSupport::Callbacks
 
-    define_callbacks :setup
+    define_callbacks :initialization
 
-    include Fargo::Publisher
     include Fargo::Supports::Chat
     include Fargo::Supports::Uploads
     include Fargo::Supports::NickList
@@ -20,141 +19,71 @@ module Fargo
     include Fargo::Supports::Timeout
     include Fargo::Supports::FileList
 
-    # Options
-    #   :hub_port
-    #   :hub_address
-    #   :search_port
-    #   :active_port
-    #   :nick
-    #   :password
-    #   :email
-    #   :speed
-    #   :passive
-    #   :download_slots
-    #   :download_dir
-    #   :slots
     configure do |config|
-      config.download_dir = '/tmp/fargo/downloads'
-      config.version      = '0.75'
-      # default the address to the address of this machine
-      config.address      = IPSocket.getaddress(Socket.gethostname)
-      config.passive      = true
-      config.nick         = 'fargo'
+      config.download_dir   = '/tmp/fargo/downloads'
+      config.address        = IPSocket.getaddress(Socket.gethostname)
+      config.passive        = false
+      config.nick           = 'fargo'
+      config.hub_address    = '127.0.0.1'
+      config.hub_port       = 7314
+      config.active_port    = 7315
+      config.search_port    = 7316
+      config.download_slots = 4
+      config.upload_slots   = 4
+      config.password       = ''
+      config.speed          = 'DSL'
+      config.email          = nil
     end
 
-    attr_reader :hub, :searcher, :active_server
+    attr_reader :hub, :channel
 
     def initialize
-      @connection_timeout_threads = {}
-    end
-
-    # Don't do this in initialization so we have time to set all the options
-    def setup
-      @hub = Fargo::Connection::Hub.new self
-      @hub.config.port    = config.hub_port if config.hub_port
-      @hub.config.address = config.hub_address if config.hub_address
-
-      unless config.passive
-        # TODO: get this working again
-        # Always create a search connection for this.
-        # searcher_options = new_options.merge :port => search_port,
-        #                                      :connection => Fargo::Connection::Search
-        # @searcher    = Fargo::Server.new searcher_options
-        #
-        # # For now, being active means that you can only download things. Always make a
-        # # connection which downloads things.
-        # active_options     = new_options.merge :port => active_port,
-        #                                        :connection => Fargo::Connection::Download
-        # @active_server = Fargo::Server.new active_options
-      end
+      run_callbacks :initialization do
+        @channel             = EventMachine::Channel.new
+        @connection_timeouts = {}
 
-      run_callbacks :setup
-    end
-
-    def get_info nick
-      hub.write "$GetINFO #{nick} #{config.nick}"
-    end
-
-    def get_ip *nicks
-      hub.write "$UserIP #{nicks.flatten.join '$$'}"
-    end
-
-    def connect_with nick
-      @connection_timeout_threads[nick] = Thread.start do
-        sleep 10
-        connection_timeout! nick
-      end
-
-      if config.passive
-        hub.write "$RevConnectToMe #{self.config.nick} #{nick}"
-      else
-        hub.write "$ConnectToMe #{nick} #{config.address}:#{config.active_port}"
+        @channel.subscribe do |type, hash|
+          Fargo.logger.debug "Channel received: #{type} - #{hash.inspect}"
+        end
       end
     end
 
-    def connected_with! nick
-      return unless @connection_timeout_threads.has_key?(nick)
-      @connection_timeout_threads.delete(nick).exit
-    end
-
     def connect
-      setup if hub.nil?
-
-      # connect all our associated servers
-      hub.connect
+      EventMachine.error_handler{ |e|
+        Fargo.logger.debug "Error raised during event loop: #{e.message}"
+        Fargo.logger.debug e.backtrace.join("\n")
+      }
+
+      EventMachine.connect config.hub_address, config.hub_port,
+          Fargo::Protocol::Hub do |conn|
+        @hub        = conn
+        @hub.client = self
+      end
 
       unless config.passive
-        searcher.connect
-        active_server.connect
+        EventMachine.start_server '0.0.0.0', config.active_port,
+            Fargo::Protocol::Download do |conn|
+          conn.client = self
+        end
+
+        EventMachine.open_datagram_socket '0.0.0.0', config.search_port,
+            Fargo::Protocol::DC do |conn|
+          conn.client = self
+        end
       end
-
-      true
     end
 
     def connected?
-      hub.try :connected?
+      EventMachine.reactor_running?
     end
 
     def disconnect
-      return if hub.nil?
-
-      Fargo.logger.info "Disconnecting from hub."
-      hub.disconnect
-      unless config.passive
-        searcher.disconnect
-        active_server.disconnect
-      end
-    end
-
-    def search_hub query
-      raise ConnectionError.new('Not connected Yet!') if hub.nil?
-
-      if config.passive
-        location = "Hub:#{config.nick}"
-      else
-        location = "#{config.address}:#{config.search_port}"
-      end
-
-      hub.write "$Search #{location} #{query.to_s}"
-    end
-
-    # see hub/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
-      []
+      Fargo.logger.info 'Disconnecting from hub.'
+      EventMachine.stop_event_loop
     end
 
     def description
-      "<++ V:#{config.version},M:#{config.passive ? 'P' : 'A'},H:1/0/0,S:#{open_slots},Dt:1.2.0/W>"
-    end
-
-    private
-
-    def connection_timeout! nick
-      @connection_timeout_threads.delete(nick)
-      publish :connection_timeout, :nick => nick
+      "<fargo V:#{Fargo::VERSION},M:#{config.passive ? 'P' : 'A'},H:1/0/0,S:#{open_slots},Dt:1.2.6/W>"
     end
 
   end

data/lib/fargo/protocol/dc.rb

@@ -0,0 +1,52 @@
+module Fargo
+  module Protocol
+    module DC
+
+      include Fargo::Parser
+      attr_accessor :client
+
+      def post_init
+        @received_data = ''
+      end
+
+      def receive_message type, message
+        client.channel << [type, message] if client
+      end
+
+      def send_message method, args = nil
+        if args
+          data = "$#{method} #{args}|"
+        else
+          data = "$#{method}|"
+        end
+
+        Fargo.logger.debug "#{self} Sending: #{data.inspect}"
+        send_data data
+      end
+
+      def receive_data data
+        @received_data << data
+
+        while message = @received_data.slice!(/[^\|]+\|/)
+          message.chomp! '|'
+          Fargo.logger.debug "#{self}: Received: #{message.inspect}"
+          hash = parse_message message
+          receive_message hash[:type], hash
+        end
+      end
+
+      def publish_args
+        {}
+      end
+
+      def unbind
+        if client
+          connection_type = self.class.name.split('::').last.downcase
+          args = [:"#{connection_type}_disconnected", publish_args]
+          client.channel << args
+        end
+      end
+
+    end
+  end
+end

data/lib/fargo/{connection → protocol}/download.rb

@@ -1,44 +1,36 @@
 require 'zlib'
 
 module Fargo
-  module Connection
-    class Download < Base
+  module Protocol
+    class Download < EventMachine::Connection
 
       include Fargo::Utils
-      include Fargo::Parser
+      include Fargo::Protocol::DC
 
-      set_callback :listen, :before, :pre_listen
-      set_callback :listen, :after do |connection|
-        send_lock if connection.config.first
-      end
+      attr_accessor :download, :client
 
-      attr_accessor :download
+      def post_init
+        super
 
-      def pre_listen
-        Fargo.logger.debug "Initiating connection on: #{config.address}:#{config.port}"
+        set_comm_inactivity_timeout 20
 
-        config.quit_on_disconnect = false
-        @lock, @pk = generate_lock
+        @lock, @pk      = generate_lock
         @handshake_step = 0
-
-        @buffer_size = (2 << 12).freeze
       end
 
       def send_lock
-        write "$MyNick #{@client.config.nick}|$Lock #{@lock} Pk=#{@pk}"
+        @lock_sent = true
+        send_message 'MyNick', @client.config.nick
+        send_message 'Lock', "#{@lock} Pk=#{@pk}"
       end
 
-      def read_data
-        # only download if we're at the correct time
+      def receive_data data
+        # only download if we're at the correct handshake step
         return super if @handshake_step != 6
 
-        @exit_time = 20 # reset our timeout time
-
-        data = @socket.readpartial @buffer_size
-
         if @zlib
-          @zs = Zlib::Inflate.new if @zs.nil?
-          data = @zs.inflate data
+          @inflator = Zlib::Inflate.new if @inflator.nil?
+          data      = @inflator.inflate data
         end
 
         @file << data
@@ -51,33 +43,29 @@ module Fargo
           percent = @recvd.to_f / @length
           if percent - @last_published > 0.05
             @file.flush
-            publish :download_progress, :percent    => percent,
-                                        :file       => download_path,
-                                        :nick       => @other_nick,
-                                        :download   => @download,
-                                        :size       => @recvd,
-                                        :compressed => @zlib
+            @client.channel << [:download_progress, {:percent => percent,
+                                        :file           => download_path,
+                                        :nick           => @other_nick,
+                                        :download       => @download,
+                                        :size           => @recvd,
+                                        :compressed     => @zlib}]
 
             @last_published = percent
           end
 
           download_finished! if @recvd == @length
         end
-      rescue IOError => e
-        error "#{self}: IOError, disconnecting #{e}"
       end
 
-      def receive data
-        message = parse_message data
-
-        case message[:type]
+      def receive_message type, message
+        case type
           when :mynick
             if @handshake_step == 0
               @handshake_step  = 1
               @other_nick      = message[:nick]
 
-              @client.connected_with! @other_nick
-              @client.lock_connection_with! @other_nick, self
+              client.channel << [:download_opened,
+                  publish_args.merge(:connection => self)]
               @download = @client.lock_next_download! @other_nick, self
 
               if @download.try(:file).nil?
@@ -91,12 +79,12 @@ module Fargo
             if @handshake_step == 1
               @remote_lock = message[:lock]
               @handshake_step = 2
-              send_lock unless config.first
-              out = ''
-              out << '$Supports TTHF ADCGet ZLIG|'
-              out << "$Direction Download #{@my_num = rand(10000)}|"
-              out << "$Key #{generate_key @remote_lock}|"
-              write out
+
+              send_lock unless @lock_sent
+
+              send_message 'Supports', 'TTHF ADCGet ZLIG'
+              send_message 'Direction', "Download #{@my_num = rand(10000)}"
+              send_message 'Key', generate_key(@remote_lock)
             else
               error 'Premature disconnect when lock received'
             end
@@ -136,18 +124,18 @@ module Fargo
               @zlib   = message[:zlib]
               @length = message[:size]
 
-              write "$Send" unless @client_extensions.include? 'ADCGet'
+              send_message 'Send' unless @client_extensions.include? 'ADCGet'
 
-              publish :download_started, :file     => download_path,
-                                         :download => @download,
-                                         :nick     => @other_nick
+              @client.channel << [:download_started, {:file => download_path,
+                                         :download  => @download,
+                                         :nick      => @other_nick}]
             else
               error "Premature disconnect when #{message[:type]} received"
             end
 
           when :noslots
             if @download
-              Fargo.logger.debug "#{self}: No Slots for #{self[:download]}"
+              Fargo.logger.debug "#{self}: No Slots for #{@download}"
 
               download_failed! 'No Slots'
             end
@@ -158,7 +146,7 @@ module Fargo
 
           # This wasn't handled by us, proxy it on up to the client
           else
-            @client.publish message[:type], message
+            super
 
         end
       end
@@ -167,8 +155,6 @@ module Fargo
         @file = File.open download_path, 'wb'
 
         @file.seek @download.offset
-        @file.sync      = true
-        @socket.sync    = true
         @handshake_step = 5
         @last_published = 0
 
@@ -194,24 +180,11 @@ module Fargo
             Fargo.logger.debug "Enabling zlib compression on: #{@download.file}"
           end
 
-          write "$ADCGET file #{download_query} #{@download.offset} #{@download.size} #{zlig}"
+          send_message 'ADCGET', "file #{download_query} #{@download.offset} #{@download.size} #{zlig}"
         else
-          write "$Get #{@download.file}$#{@download.offset + 1}"
+          send_message 'Get', "#{@download.file}$#{@download.offset + 1}"
         end
 
-        # This is the thread for the timeout of a connection. The @exit_time
-        # variable is reset to 20 after every bit of information is received.
-        @exit_time = 20
-        @exit_thread = Thread.start {
-          while @exit_time > 0
-            sleep 1
-            @exit_time -= 1
-            Fargo.logger.debug "#{self} time out in #{@exit_time} seconds"
-          end
-
-          download_failed! 'Download timeout!'
-        }
-
         Fargo.logger.debug "#{self}: Beginning download of #{@download}"
       end
 
@@ -224,12 +197,10 @@ module Fargo
 
         reset_download
 
-        publish :download_failed, opts.merge(:nick => @other_nick,
+        @client.channel << [:download_failed, opts.merge(:nick => @other_nick,
                                              :download   => download,
                                              :file       => path,
-                                             :last_error => msg)
-
-        @exit_thread = nil
+                                             :last_error => msg)]
       end
 
       def download_finished!
@@ -241,16 +212,21 @@ module Fargo
 
         reset_download
 
-        publish :download_finished, :file => path, :download => download,
-                                    :nick => @other_nick
-        disconnect if download.file_list?
+        @client.channel << [:download_finished,
+            {:file => path, :download => download, :nick => @other_nick}]
+
+        close_connection_after_writing if download.file_list?
       end
 
-      def disconnect
-        Fargo.logger.debug "#{self} Disconnecting from: #{@other_nick}"
+      def publish_args
+        {:nick => @other_nick}
+      end
 
+      def unbind
         super
 
+        Fargo.logger.debug "#{self} Disconnected from: #{@other_nick}"
+
         if @download
           download_failed! @last_error, :recvd => @recvd, :length => @length
         end
@@ -259,25 +235,16 @@ module Fargo
       end
 
       private
+
       def reset_download
         @file.close unless @file.nil? || @file.closed?
+
         if @file_path && File.exists?(@file_path) && File.size(@file_path) == 0
           File.delete(@file_path)
         end
 
-        if @socket
-          @socket.sync = false
-          @socket.flush
-        end
-
-        # If this was called from exit thread, don't kill it
-        if @exit_thread != Thread.current
-          @exit_thread.exit if @exit_thread && @exit_thread.alive?
-          @exit_thread = nil
-        end
-
         # clear out these variables
-        @zs = @file_path = @zlib = @download = @length = @recvd = nil
+        @inflator = @file_path = @zlib = @download = @length = @recvd = nil
 
         # Go back to the get step
         @handshake_step = 5
@@ -305,7 +272,8 @@ module Fargo
 
       def error message
         Fargo.logger.warn @last_error = message
-        disconnect
+
+        close_connection
       end
 
     end

data/lib/fargo/protocol/hub.rb

@@ -0,0 +1,81 @@
+module Fargo
+  module Protocol
+    class Hub < EventMachine::Connection
+
+      include Fargo::Protocol::DC
+      include Fargo::Utils
+
+      attr_reader :hubname
+
+      # See <http://www.teamfair.info/DC-Protocol.htm> for specifics on
+      # the DC protocol
+      def receive_message type, message
+        case type
+          when :lock
+            @validated = false
+            send_message 'Key', generate_key(message[:lock])
+          when :hubname
+            @hubname = message[:name]
+            send_message 'ValidateNick', @client.config.nick unless @validated
+          when :getpass
+            send_message 'MyPass', @client.config.password
+          when :badpass, :hubfull
+            Fargo.logger.warn "Disconnecting because of: #{message.inspect}"
+            close_connection_after_writing
+          when :hello
+            if message[:who] == @client.config.nick
+              Fargo.logger.info "Connected to DC Hub #{@hubname}"
+              @validated = true
+
+              send_message 'Version', '1,0091'
+              send_message 'MyINFO', "$ALL #{@client.config.nick} " +
+                "#{@client.description}$ $#{@client.config.speed}" +
+                "#{@status || 1.chr}$#{@client.config.email}" +
+                "$#{@client.share_size}$"
+              send_message 'GetNickList'
+            end
+
+          when :connect_to_me
+            if !@client.nicks.include?(message[:nick])
+              Fargo.logger.info "Invalid connect_to_me request from: #{message[:nick]}"
+              return
+            end
+
+            EventMachine.connect message[:address], message[:port],
+                Fargo::Protocol::Download do |conn|
+              conn.client     = @client
+              conn.send_lock # We connect first, we send lock first
+            end
+
+          when :search
+            # Let the client handle the results
+            @results = @client.search_files message
+
+            # Send all the results to the peer. Take care of active/passive
+            # connections
+            @results.each { |r|
+              if message[:address]
+                r.active_send @client.config.nick, message[:ip], message[:port]
+              else
+                send_message 'SR', "#{@client.config.nick} #{r}"
+              end
+            }
+
+          when :revconnect
+            if @client.config.passive
+              send_message 'RevConnectToMe',
+                  "#{@client.config.nick} #{message[:who]}"
+            else
+              send_message 'ConnectToMe', "#{@client.config.nick} #{@client.config.address}:#{@client.config.extport}"
+            end
+
+          # proxy this message on up the stack if we don't handle it
+          else
+            super
+
+        end
+      end
+
+    end
+  end
+end

data/lib/fargo/search.rb

@@ -1,6 +1,6 @@
 module Fargo
   class Search
-    
+
     ANY        = 1
     AUDIO      = 2
     COMPRESSED = 3
@@ -8,38 +8,43 @@ module Fargo
     EXECUTABLE = 5
     VIDEO      = 7
     FOLDER     = 8
-  
+
     attr_accessor :size_restricted, :is_minimum_size, :size, :filetype, :pattern
-  
+
     def initialize opts = {}
-      self.size_restricted = opts[:size_restricted]
-      self.is_minimum_size = opts[:is_minimum_size]
-      self.size = opts[:size]
-      self.filetype = opts[:filetype] || ANY
+      @size_restricted = opts[:size_restricted]
+      @is_minimum_size = opts[:is_minimum_size]
+      @size            = opts[:size]
+      @filetype        = opts[:filetype] || ANY
+
       if opts[:pattern]
-        self.pattern = opts[:pattern]
+        @pattern = opts[:pattern]
       elsif opts[:query]
         self.query = opts[:query]
       end
     end
-  
+
     def query= query
       @pattern = query.split(' ').join('$')
     end
-    
+
     def queries
-      pattern.split("$")
+      pattern.split('$')
     end
 
     def query
       pattern.gsub('$', ' ')
     end
-    
+
     def matches_result? map
       file = map[:file].downcase
-      matches_query = queries.inject(true) { |last, word| last && file.index(word.downcase) }
+
+      matches_query = queries.inject(true) do |last, word|
+        last && file.index(word.downcase)
+      end
+
       if size_restricted == 'T'
-        if is_minimum_size 
+        if is_minimum_size
           matches_query && map[:size] > size
         else
           matches_query && map[:size] < size
@@ -51,11 +56,11 @@ module Fargo
 
     def to_s
       if size_restricted
-        "#{size_restricted ? 'T' : 'F' }?#{!size_restricted || is_minimum_size ? 'T' : 'F'}?#{size || 0}?#{filetype}?#{pattern}"      
+        "#{size_restricted ? 'T' : 'F' }?#{!size_restricted || is_minimum_size ? 'T' : 'F'}?#{size || 0}?#{filetype}?#{pattern}"
       else
         "F?T?#{size || 0}?#{filetype}?#{pattern}"
       end
     end
-  
+
   end
 end