fargo 0.2.0 → 0.3.0

data/lib/fargo/supports/nick_list.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/numeric/time'
+
 module Fargo
   module Supports
     module NickList
@@ -33,9 +35,14 @@ module Fargo
         @nick_info[nick]
       end
 
+      # This query must be up to date so remove any cached information we have
+      # about the nick so we can get a fresh copy
       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
+        if @search_result_slots[nick] &&
+            @search_result_slots[nick][:updated_at] + 10.minutes > Time.now
+          return @search_result_slots[nick][:slots] > 0
+        end
+
         @nick_info.try :delete, nick
         info = info nick
 
@@ -54,23 +61,29 @@ module Fargo
       def initialize_nick_lists
         @nicks     = []
         @nick_info = Hash.new{ |h, k| h[k] = {} }
+        @search_result_slots = {}
 
         channel.subscribe do |type, map|
           case type
             when :hello
-              @nicks << map[:who] unless @nicks.include? map[:who]
+              @nicks << map[:nick] unless @nicks.include? map[:nick]
             when :myinfo
               @nick_info[map[:nick]] = map
             when :nick_list
               @nicks = map[:nicks]
             when :quit
-              @nicks.delete map[:who]
-              @nick_info.delete map[:who]
+              @nicks.delete map[:nick]
+              @nick_info.delete map[:nick]
             when :hub_disconnected
               @nicks.clear
               @nick_info.clear
             when :userip
               map[:users].each_pair{ |nick, ip| @nick_info[nick][:ip] = ip }
+            when :search_result
+              @search_result_slots[map[:nick]] = {
+                :slots      => map[:open_slots],
+                :updated_at => Time.now
+              }
           end
         end
       end

data/lib/fargo/supports/persistence.rb

@@ -10,7 +10,7 @@ module Fargo
       def connect_with nick
         @connection_timeouts[nick] = EventMachine::Timer.new(10) do
           @connection_timeouts.delete(nick)
-          channel.push [:connection_timeout, {:nick => nick}]
+          channel << [:connection_timeout, {:nick => nick}]
         end
 
         if config.passive
@@ -46,7 +46,7 @@ module Fargo
         channel.subscribe do |type, hash|
           if type == :hub_disconnected
             nicks_connected_with.each{ |n| disconnect_from n }
-          elsif type == :download_disconnected
+          elsif type == :peer_disconnected
             @connection_cache.delete hash[:nick]
           elsif type == :download_opened
             @connection_timeouts.delete(hash[:nick]).try(:cancel)

data/lib/fargo/supports/{file_list.rb → remote_file_list.rb}

@@ -2,9 +2,10 @@ require 'bzip2'
 require 'libxml'
 
 module Fargo
+  class Listing < Struct.new(:tth, :size, :name, :nick, :mtime, :root); end
+
   module Supports
-    module FileList
-      class Listing < Struct.new(:tth, :size, :name, :nick); end
+    module RemoteFileList
 
       extend ActiveSupport::Concern
 
@@ -61,7 +62,7 @@ module Fargo
         parse_file_list list, nick
       end
 
-      private
+      protected
 
       def parse_file_list file, nick
         if file && File.exists?(file)
@@ -95,8 +96,6 @@ module Fargo
         list
       end
 
-      protected
-
       def initialize_file_lists
         @file_list = {}
         @getting_file_list = {}

data/lib/fargo/supports/searches.rb

@@ -7,15 +7,6 @@ module Fargo
         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?
 
@@ -55,8 +46,8 @@ module Fargo
       protected
 
       def normalize search
-        unless search.is_a? Fargo::Search
-          search = Fargo::Search.new :query => search
+        unless search.is_a? Search
+          search = Search.new :query => search
         end
 
         search
@@ -68,8 +59,10 @@ module Fargo
 
         channel.subscribe do |type, map|
           if type == :search_result
+            map[:tth] = map[:hub] if map[:hub] =~ /^TTH:/
+
             @searches.keys.each do |search|
-              if @search_objects[search].matches_result?(map)
+              if @search_objects[search].matches?(map)
                 @searches[search] << map
               end
             end

data/lib/fargo/supports/uploads.rb

@@ -1,14 +1,33 @@
+require 'active_support/core_ext/module/synchronization'
+
 module Fargo
   module Supports
     module Uploads
-      # TODO: write this module...
+      extend ActiveSupport::Concern
+
+      included do
+        set_callback :initialization, :after, :initialize_upload_locks
+      end
+
+      def open_upload_slots
+        [config.upload_slots - @taken_slots, 0].max
+      end
 
-      def open_slots
-        0
+      def take_slot!
+        @taken_slots += 1
       end
 
-      def share_size
-        5368709121 # 5 GB + 1 byte
+      def release_slot!
+        @taken_slots -= 1
+      end
+
+      synchronize :take_slot!, :release_slot!, :with => :@upload_slot_lock
+
+      protected
+
+      def initialize_upload_locks
+        @upload_slot_lock = Mutex.new
+        @taken_slots      = 0
       end
 
     end

data/lib/fargo/version.rb

@@ -1,3 +1,3 @@
 module Fargo
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/lib/fargo.rb

@@ -2,6 +2,7 @@ require 'fileutils'
 require 'eventmachine'
 require 'active_support/dependencies/autoload'
 require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/module/delegation'
 require 'active_support/buffered_logger'
 require 'active_support/concern'
 require 'active_support/configurable'
@@ -11,7 +12,7 @@ module Fargo
 
   class ConnectionException < RuntimeError; end
 
-  mattr_accessor:logger
+  mattr_accessor :logger
   self.logger = ActiveSupport::BufferedLogger.new STDOUT
 
   autoload :Utils
@@ -21,6 +22,8 @@ module Fargo
   autoload :SearchResult
   autoload :VERSION
   autoload :TTH
+  autoload :Listing, 'fargo/supports/remote_file_list'
+  autoload :Download, 'fargo/supports/downloads'
 
   module Supports
     extend ActiveSupport::Autoload
@@ -32,15 +35,21 @@ module Fargo
     autoload :Downloads
     autoload :Persistence
     autoload :Timeout
-    autoload :FileList
+    autoload :RemoteFileList
+    autoload :LocalFileList
   end
 
   module Protocol
     extend ActiveSupport::Autoload
 
     autoload :DC
-    autoload :Download
+    autoload :Peer
+    autoload :PeerDownload
+    autoload :PeerUpload
     autoload :Hub
   end
 
+  class << self
+    delegate :config, :configure, :to => Client
+  end
 end

data/spec/fargo/parser_spec.rb

@@ -0,0 +1,198 @@
+require 'spec_helper'
+
+describe Fargo::Parser do
+
+  let(:helper) { helper_object described_class }
+
+  it "correctly parses info strings" do
+    helper.parse_message(
+      "$MyINFO $ALL notdan <++ V:0.75,M:A,H:1/0/0,S:1,Dt:1.2.6/W>$ $Morewood A-D\001$$90932631814$"
+    ).should == {
+      :type      => :myinfo,
+      :nick      => 'notdan',
+      :speed     => 'Morewood A-D',
+      :email     => '',
+      :sharesize => 90932631814,
+      :interest  => '<++ V:0.75,M:A,H:1/0/0,S:1,Dt:1.2.6/W>'
+    }
+  end
+
+  it "correctly parses hello commands" do
+    helper.parse_message("$Hello notdan").should == {
+      :type => :hello,
+      :nick => 'notdan'
+    }
+  end
+
+  it "correctly parses the quit command" do
+    helper.parse_message("$Quit ghostafaria").should == {
+      :type => :quit,
+      :nick => 'ghostafaria'
+    }
+  end
+
+  it "correctly parses search commands" do
+    helper.parse_message(
+      "$Search 128.237.66.53:36565 F?T?0?1?west$wing").should == {
+      :type            => :search,
+      :restrict_size   => false,
+      :is_minimum_size => false,
+      :pattern         => 'west$wing',
+      :filetype        => 1,
+      :address         => '128.237.66.53',
+      :port            => 36565,
+      :size            => 0
+    }
+  end
+
+  describe 'search results' do
+    context 'active searches' do
+      it "correctly parses search results which are files" do
+        helper.parse_message(
+          "$SR notas 02 - Heroes.mp3\0053001347 "+
+          "2/4\005TTH:VZWDTXHBSBSW7UMKCFHNEHXWCSWWYGU4KTIL76A " +
+          "(127.0.0.1:7314)").should == {
+          :type       => :search_result,
+          :open_slots => 2,
+          :slots      => 4,
+          :hub        => 'TTH:VZWDTXHBSBSW7UMKCFHNEHXWCSWWYGU4KTIL76A',
+          :file       => '02 - Heroes.mp3',
+          :address    => '127.0.0.1',
+          :port       => 7314,
+          :size       => 3001347,
+          :nick       => 'notas'
+        }
+      end
+
+      it "correctly parses search results which are directories" do
+        helper.parse_message(
+          "$SR notas Music 2/4\005" +
+          "TTH:EAAABGHTP4AAACAAAAAAAAAAACIOWCMZ6N7QAAA (127.0.0.1:7314)"
+        ).should == {
+          :type       => :search_result,
+          :open_slots => 2,
+          :slots      => 4,
+          :hub        => 'TTH:EAAABGHTP4AAACAAAAAAAAAAACIOWCMZ6N7QAAA',
+          :dir        => 'Music',
+          :address    => '127.0.0.1',
+          :port       => 7314,
+          :nick       => 'notas'
+        }
+      end
+    end
+
+    context 'passive searches' do
+      it "correctly parses search results which are files" do
+        helper.parse_message(
+          "$SR notas 02 - Heroes.mp3\0053001347 "+
+          "2/4\005TTH:VZWDTXHBSBSW7UMKCFHNEHXWCSWWYGU4KTIL76A " +
+          "(127.0.0.1:7314)\005user2").should == {
+          :type       => :search_result,
+          :open_slots => 2,
+          :slots      => 4,
+          :hub        => 'TTH:VZWDTXHBSBSW7UMKCFHNEHXWCSWWYGU4KTIL76A',
+          :file       => '02 - Heroes.mp3',
+          :address    => '127.0.0.1',
+          :port       => 7314,
+          :size       => 3001347,
+          :nick       => 'notas'
+        }
+      end
+
+      it "correctly parses search results which are directories" do
+        helper.parse_message(
+          "$SR notas Music 2/4\005" +
+          "TTH:EAAABGHTP4AAACAAAAAAAAAAACIOWCMZ6N7QAAA (127.0.0.1:7314)\005nick"
+        ).should == {
+          :type       => :search_result,
+          :open_slots => 2,
+          :slots      => 4,
+          :hub        => 'TTH:EAAABGHTP4AAACAAAAAAAAAAACIOWCMZ6N7QAAA',
+          :dir        => 'Music',
+          :address    => '127.0.0.1',
+          :port       => 7314,
+          :nick       => 'notas'
+        }
+      end
+    end
+  end
+
+  describe 'the ADC draft' do
+    it 'correctly parses the ADCSND command with ZL1' do
+      helper.parse_message(
+        "$ADCSND file TTH/PPUROLR2WSYTGPLCM3KV4V6LJC36SCTFQJFDJKA 0 1154 ZL1"
+      ).should == {
+        :type   => :adcsnd,
+        :offset => 0,
+        :file   => 'TTH/PPUROLR2WSYTGPLCM3KV4V6LJC36SCTFQJFDJKA',
+        :size   => 1154,
+        :zlib   => true,
+        :kind   => 'file'
+      }
+    end
+
+    it 'correctly parses the ADCSND command without ZL1' do
+      helper.parse_message(
+        "$ADCSND file TTH/PPUROLR2WSYTGPLCM3KV4V6LJC36SCTFQJFDJKA 4 1154"
+      ).should == {
+        :type   => :adcsnd,
+        :offset => 4,
+        :file   => 'TTH/PPUROLR2WSYTGPLCM3KV4V6LJC36SCTFQJFDJKA',
+        :size   => 1154,
+        :zlib   => false,
+        :kind   => 'file'
+      }
+    end
+
+    it 'correctly parses the ADCGET command with ZL1' do
+      helper.parse_message(
+        "$ADCGET file TTH/PPUROLR2WSYTGPLCM3KV4V6LJC36SCTFQJFDJKA 0 1154 ZL1"
+      ).should == {
+        :type   => :adcget,
+        :offset => 0,
+        :file   => 'TTH/PPUROLR2WSYTGPLCM3KV4V6LJC36SCTFQJFDJKA',
+        :size   => 1154,
+        :zlib   => true,
+        :kind   => 'file'
+      }
+    end
+
+    it 'correctly parses the ADCGET command without ZL1' do
+      helper.parse_message(
+        "$ADCGET file TTH/PPUROLR2WSYTGPLCM3KV4V6LJC36SCTFQJFDJKA 4 1154"
+      ).should == {
+        :type   => :adcget,
+        :offset => 4,
+        :file   => 'TTH/PPUROLR2WSYTGPLCM3KV4V6LJC36SCTFQJFDJKA',
+        :size   => 1154,
+        :zlib   => false,
+        :kind   => 'file'
+      }
+    end
+  end
+
+  it "parses a chat message correctly" do
+    helper.parse_message('<fargo> hello there!').should == {
+      :type => :chat,
+      :from => 'fargo',
+      :text => 'hello there!'
+    }
+  end
+
+  it "doesn't die on something which it does not match" do
+    helper.parse_message('$NoMatch here').should == {
+      :type => :mystery,
+      :text => '$NoMatch here'
+    }
+
+    helper.parse_message('NoMatch here').should == {
+      :type => :mystery,
+      :text => 'NoMatch here'
+    }
+
+    helper.parse_message('').should == {
+      :type => :mystery,
+      :text => ''
+    }
+  end
+end

data/spec/fargo/protocol/dc_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe Fargo::Protocol::DC do
+  let(:conn) { helper_object described_class }
+  let(:client) { Fargo::Client.new }
+
+  before :each do
+    conn.post_init
+  end
+
+  context "receiving data" do
+    it "parses the received data and passes it along to :receive_message" do
+      conn.should_receive(:receive_message).with(:hello,
+        :type => :hello, :nick => 'fargo')
+
+      conn.receive_data '$Hello fargo|'
+    end
+
+    it "handles receiving two chunks of data at once" do
+      conn.should_receive(:receive_message).with(:hello,
+        :type => :hello, :nick => 'fargo').ordered
+      conn.should_receive(:receive_message).with(:hello,
+        :type => :hello, :nick => 'foobar').ordered
+
+      conn.receive_data '$Hello fargo|$Hello foobar|'
+    end
+
+    it "handles receiving data in partial chunks" do
+      conn.should_receive(:receive_message).with(:hello,
+        :type => :hello, :nick => 'fargo').ordered
+      conn.should_receive(:receive_message).with(:hello,
+        :type => :hello, :nick => 'foobar').ordered
+
+      conn.receive_data '$Hello far'
+      conn.receive_data 'go|$Hello'
+      conn.receive_data ' foobar|'
+    end
+
+    it "doesn't call unnecessary methods when the data hasn't been received" do
+      conn.should_receive(:receive_message).with(:hello,
+        :type => :hello, :nick => 'fargo').ordered
+
+      conn.receive_data '$Hello fargo|$Hello fooba'
+    end
+
+    it "passes all binary data to :receive_data_chunk when necessary" do
+      conn.should_receive(:receive_message).with(:hello,
+        :type => :hello, :nick => 'fargo'){ |*args|
+        conn.stub(:parse_data?).and_return false
+        conn.should_receive(:receive_data_chunk).with('asdf')
+      }
+
+      conn.receive_data '$Hello fargo|'
+      conn.receive_data 'asdf'
+    end
+  end
+
+  context "sending data" do
+    it "appends a $ to all commands sent with a pipe at the end" do
+      conn.should_receive(:send_data).with('$Foo|')
+      conn.send_message 'Foo'
+    end
+
+    it "allows for arguments to be specified as well" do
+      conn.should_receive(:send_data).with('$Foo bar baz|')
+      conn.send_message 'Foo', 'bar baz'
+    end
+  end
+
+  it "alerts the client when it's been disconnected" do
+    conn.client = client
+    client.channel.should_receive(:<<).with(
+      [:dc_disconnected, instance_of(Hash)])
+
+    conn.unbind
+  end
+end

data/spec/fargo/protocol/hub_spec.rb

@@ -0,0 +1,155 @@
+require 'spec_helper'
+
+describe Fargo::Protocol::Hub do
+  let(:conn) {
+    helper_object(described_class).tap do |conn|
+      conn.client = Fargo::Client.new
+      conn.post_init
+    end
+  }
+  include Fargo::TTH
+
+  context "searches" do
+    let(:file1) { Fargo.config.download_dir + '/file12' }
+    let(:file2) { Fargo.config.download_dir + '/file23' }
+    let(:file3) { Fargo.config.download_dir + '/file34' }
+
+    before :each do
+      File.open(file1, 'w'){ |f| f << 'garbage' }
+      File.open(file2, 'w'){ |f| f << 'garbage' }
+      File.open(file3, 'w'){ |f| f << 'garbage' }
+      conn.client = Fargo::Client.new
+      conn.client.stub(:nicks).and_return ['foobar']
+      conn.client.share_directory Fargo.config.download_dir
+      conn.post_init
+    end
+
+    it "searches results and sends the results to the hub" do
+      conn.should_receive(:send_message).with('SR',
+        "fargo tmp\\file12\0057 4/4\005TTH:#{file_tth file1} " +
+        "(127.0.0.1:7314)\005foobar")
+
+      query = Fargo::Search.new :query => 'file1'
+      conn.receive_data "$Search Hub:foobar #{query}|"
+    end
+
+    it "sends all hits to the hub" do
+      conn.should_receive(:send_message).with('SR',
+        "fargo tmp\\file23\0057 4/4\005TTH:#{file_tth file2} " +
+        "(127.0.0.1:7314)\005foobar")
+
+      conn.should_receive(:send_message).with('SR',
+        "fargo tmp\\file34\0057 4/4\005TTH:#{file_tth file3} " +
+        "(127.0.0.1:7314)\005foobar")
+
+      query = Fargo::Search.new :query => '3'
+      conn.receive_data "$Search Hub:foobar #{query}|"
+    end
+
+    it "sends active hits via EventMachine" do
+      stub = double 'connection'
+      stub.should_receive(:send_datagram).with('$SR ' +
+        "fargo tmp\\file12\0057 4/4\005TTH:#{file_tth file1} " +
+        "(127.0.0.1:7314)|", '127.0.0.1', 7000).ordered
+      stub.should_receive(:close_connection_after_writing).ordered
+
+      EventMachine.stub(:open_datagram_socket).with('0.0.0.0', 0).
+        and_return stub
+
+      query = Fargo::Search.new :query => 'file1'
+      conn.receive_data "$Search 127.0.0.1:7000 #{query}|"
+    end
+  end
+
+  context "$RevConnectToMe" do
+    it "responds with $ConnectToMe when the client is active" do
+      conn.client.config.passive = false
+      conn.client.config.address = '1.2.3.4'
+      conn.client.config.active_port = 728
+      conn.should_receive(:send_data).with('$ConnectToMe foobar 1.2.3.4:728|')
+
+      conn.receive_data '$RevConnectToMe foobar fargo|'
+    end
+
+    it "responds with $RevConnectToMe when the client is passive" do
+      conn.client.config.passive = true
+      conn.should_receive(:send_data).with('$RevConnectToMe fargo foobar|')
+
+      conn.receive_data '$RevConnectToMe foobar fargo|'
+    end
+  end
+
+  it "connects to a client when receiving $ConnectToMe" do
+    EventMachine.should_receive(:connect).with('1.2.3.4', 500,
+      Fargo::Protocol::Peer)
+
+    conn.receive_data '$ConnectToMe fargo 1.2.3.4:500|'
+  end
+
+  it "proxies specifically unhandled messages to the client" do
+    conn.client.channel.should_receive(:<<).with [:nick_list, instance_of(Hash)]
+
+    conn.receive_data '$NickList a$$b|'
+  end
+
+  it "says that :hub_disconnected when the hub disconnects" do
+    conn.client.channel.should_receive(:<<).with(
+      [:hub_disconnected, instance_of(Hash)])
+
+    conn.unbind
+  end
+
+  context "the hub handshake" do
+    before :each do
+      Fargo.configure do |config|
+        config.nick                = 'fargo'
+        config.speed               = 'DSL'
+        config.override_share_size = nil
+        config.email               = 'asdf'
+        config.passive             = false
+        config.upload_slots        = 5
+      end
+    end
+
+    it "replies with a valid key when the lock is sent" do
+      conn.should_receive(:send_data).with "$Key 4\220/%DCN000%/|"
+
+      conn.receive_data "$Lock FOO Pk=BAR|"
+    end
+
+    it "tries to validate the client's nick when the $HubName is received" do
+      conn.should_receive(:send_data).with "$ValidateNick fargo|"
+
+      conn.receive_data '$HubName foobar|'
+    end
+
+    it "sends $Version, $MyInfo, and $GetNickList upon confirmation of nick" do
+      conn.should_receive(:send_data).with('$Version 1,0091|').ordered
+      conn.should_receive(:send_data).with(
+        "$MyINFO $ALL fargo <fargo V:#{Fargo::VERSION},M:A,H:1/0/0,S:5," +
+        "Dt:1.2.6/W>$ $DSL\001$asdf$0$|").ordered
+      conn.should_receive(:send_data).with('$GetNickList|').ordered
+
+      conn.receive_data '$Hello fargo|'
+    end
+
+    it "sends the configured password when requested" do
+      conn.client.config.password = 'foobar'
+      conn.should_receive(:send_data).with('$MyPass foobar|')
+
+      conn.receive_data '$GetPass|'
+    end
+
+    it "disconnects when the password was bad" do
+      conn.should_receive(:close_connection_after_writing)
+
+      conn.receive_data '$BadPass|'
+    end
+
+    it "disconnects when the hub is full" do
+      conn.should_receive(:close_connection_after_writing)
+
+      conn.receive_data '$HubIsFull|'
+    end
+  end
+end