fargo 0.1.0

data/lib/fargo/supports/file_list.rb

@@ -0,0 +1,84 @@
+require 'bzip2'
+require 'libxml'
+
+module Fargo
+  module Supports
+    module FileList
+      class Listing < Struct.new(:tth, :size, :name); 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 ||= {}
+        return parse_file_list(@file_list[nick]) if @file_list.has_key?(nick)
+
+        file_gotten = lambda{ |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]
+              end
+          end
+        }
+
+        subscribe &file_gotten
+
+        download nick, 'files.xml.bz2'
+      end
+
+      # Wait for the results to arrive, timed out after some time
+      def file_list! nick, timeout = 10
+        @file_list ||= {}
+        return parse_file_list(@file_list[nick]) if @file_list.has_key?(nick)
+
+        list = nil
+        list_gotten = lambda{ |type, map|
+          if type == :file_list && map[:nick] == nick
+            list = map[:list]
+            true
+          else
+            false
+          end
+        }
+
+        timeout_response(timeout, list_gotten){ file_list nick }
+
+        parse_file_list list
+      end
+
+      private
+
+      def parse_file_list file
+        if file && File.exists?(file)
+          xml = Bzip2::Reader.open(file).read
+          doc = LibXML::XML::Document.string xml
+
+          construct_file_list doc.root
+        else
+          nil
+        end
+      end
+
+      def construct_file_list node
+        list = {}
+
+        node.each_element do |element|
+          element_name = element['Name']
+          if element.name =~ /directory/i
+            list[element_name] = construct_file_list element
+          else
+            list[element_name] = Listing.new(
+              element['TTH'],
+              element['Size'],
+              element_name
+            )
+          end
+        end
+
+        list
+      end
+    end
+  end
+end

data/lib/fargo/supports/nick_list.rb

@@ -0,0 +1,71 @@
+module Fargo
+  module Supports
+    module NickList
+      extend ActiveSupport::Concern
+      
+      included do
+        set_callback :setup, :after, :subscribe_to_nicks
+      end
+      
+      attr_accessor :nicks
+      
+      def info nick
+        return nil unless @nick_info
+        if @nick_info.has_key?(nick) || !connected? || !@nicks.include?(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
+        }
+        timeout_response(5, info_gotten){ get_info nick }
+
+        @nick_info[nick]
+      end
+      
+      def 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
+        info = info nick
+
+        return false if info.nil?
+        return true  if info[:interest].nil?
+
+        match = info[:interest].match /.*?<.*S:(\d+).*>/
+        return true if match.nil?
+
+        Fargo.logger.debug "#{self} User: #{nick} has #{match[1]} open slots"
+        match[1].to_i > 0
+      end
+      
+      def subscribe_to_nicks
+        @nicks     = []
+        @nick_info = Hash.new{ |h, k| h[k] = {} }
+
+        subscribe do |type, map|
+          case type
+            when :hello
+              @nicks << map[:who] unless @nicks.include? map[:who]
+            when :myinfo
+              @nick_info[map[:nick]] = map
+            when :nick_list
+              @nicks = map[:nicks]
+            when :quit
+              @nicks.delete map[:who]
+              @nick_info.delete map[:who]
+            when :hub_disconnected
+              @nicks.clear
+              @nick_info.clear
+            when :userip
+              map[:users].each_pair{ |nick, ip| @nick_info[nick][:ip] = ip }
+          end
+        end
+      end
+    
+    end
+  end
+end

data/lib/fargo/supports/persistence.rb

@@ -0,0 +1,52 @@
+module Fargo
+  module Supports
+    module Persistence
+      extend ActiveSupport::Concern
+
+      included do
+        set_callback :setup, :after, :setup_connection_cache
+      end
+
+      def lock_connection_with! nick, connection
+        @connection_cache[nick] = connection
+      end
+
+      def connection_for nick
+        c = @connection_cache.try :[], nick
+        return c if c.nil? || c.connected?
+
+        # If it's present and not connected, remove it from the cache
+        @connection_cache.try :delete, nick
+        nil
+      end
+      
+      def connected_with? nick
+        c = @connection_cache.try :[], nick
+        c.connected? unless c.nil?
+      end 
+      
+      def disconnect_from nick
+        c = @connection_cache.try :delete, nick
+        c.disconnect unless c.nil?
+      end
+      
+      def nicks_connected_with
+        return [] if @connection_cache.nil?
+
+        nicks = @connection_cache.keys
+        nicks.reject{ |n| !connected_with? n } 
+      end
+      
+      def setup_connection_cache
+        @connection_cache = {}
+
+        subscribe { |type, hash|
+          if type == :hub_disconnected
+            nicks_connected_with.each{ |n| disconnect_from n }
+          end
+        }
+      end
+
+    end
+  end
+end

data/lib/fargo/supports/searches.rb

@@ -0,0 +1,64 @@
+module Fargo
+  module Supports
+    module Searches
+      extend ActiveSupport::Concern
+      
+      included do
+        set_callback :setup, :after, :subscribe_to_searches
+      end
+
+      def search search
+        raise ConnectionException.new 'Not connected yet!' unless connected?
+
+        search                       = normalize search
+        @searches[search.to_s]       = []
+        @search_objects[search.to_s] = search
+        search_hub search
+      end
+
+      def searches
+        @searches.keys.map { |k| @search_objects[k] } if @searches
+      end
+
+      def search_results search
+        search = normalize search
+        @searches[search.to_s] if @searches
+      end
+
+      def remove_search search
+        search = normalize search
+        @searches.delete search.to_s if @searches
+        @search_objects.delete search.to_s if @search_objects
+      end
+
+      private
+
+      def normalize search
+        unless search.is_a? Fargo::Search
+          search = Fargo::Search.new :query => search
+        end
+
+        search
+      end
+
+      def subscribe_to_searches
+        @searches       = {}
+        @search_objects = {}
+
+        subscribe do |type, map|
+          if type == :search_result
+            @searches.keys.each do |search|
+              if @search_objects[search].matches_result?(map)
+                @searches[search] << map
+              end
+            end
+          elsif type == :hub_disconnected
+            @searches.clear
+            @search_objects.clear
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/fargo/supports/timeout.rb

@@ -0,0 +1,19 @@
+module Fargo
+  module Supports
+    module Timeout
+      
+      def timeout_response timeout, succeed_subscription
+        thread = Thread.current
+        subscribed_block = lambda do |*args|
+          thread.wakeup if succeed_subscription.call(*args)
+        end
+
+        subscribe &subscribed_block
+        yield
+        sleep timeout
+        unsubscribe &subscribed_block
+      end
+
+    end
+  end
+end

data/lib/fargo/supports/uploads.rb

@@ -0,0 +1,16 @@
+module Fargo
+  module Supports
+    module Uploads
+      # TODO: write this module...
+      
+      def open_slots
+        0
+      end
+      
+      def share_size
+        5368709121 # 5 GB + 1 byte    
+      end
+      
+    end
+  end
+end

data/lib/fargo/utils.rb

@@ -0,0 +1,35 @@
+module Fargo
+  module Utils
+    
+    # Lord knows why they're doing this...
+    def generate_key lock
+      lock_bytes = lock.bytes.to_a
+      bytes = []
+      bytes << (lock_bytes[0] ^ lock_bytes[-1] ^ lock_bytes[-2] ^ 5)
+      (1..lock.length-1).each{ |i| 
+        bytes << (lock_bytes[i] ^ lock_bytes[i - 1])
+      }
+
+      key = ''
+      bytes.each{ |b| key << encode_char(((b << 4) | (b >> 4)) & 0xff) }
+      key
+    end
+  
+    # Generates a lock between 80 and 134 random characters, and a pk of 16
+    # random characters. At least in theory, other clients were doing exactly
+    # this, so I just mirrored them.
+    def generate_lock
+      lock = 'EXTENDEDPROTOCOL'
+      [lock + ('ABC' * 6), 'ABCD' * 4]
+    end
+  
+    # Watch out for those special ones...
+    def encode_char c
+      if [0, 5, 36, 96, 124, 126].include? c
+        sprintf '/%%DCN%03d%%/', c
+      else
+        c.chr
+      end
+    end
+  end
+end

data/lib/fargo/version.rb

@@ -0,0 +1,3 @@
+module Fargo
+  VERSION = '0.1.0'
+end

data/lib/fargo.rb

@@ -0,0 +1,48 @@
+require 'socket'
+require 'fileutils'
+require 'active_support/dependencies/autoload'
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/buffered_logger'
+require 'active_support/concern'
+
+module Fargo
+  extend ActiveSupport::Autoload
+
+  class ConnectionException < RuntimeError; end
+  
+  mattr_accessor:logger
+  self.logger = ActiveSupport::BufferedLogger.new STDOUT
+
+  autoload :Utils  
+  autoload :Publisher
+  autoload :Parser
+  autoload :Server
+  autoload :Client
+  autoload :Search
+  autoload :SearchResult
+  autoload :VERSION
+
+  module Supports
+    extend ActiveSupport::Autoload
+
+    autoload :Chat
+    autoload :Searches
+    autoload :NickList
+    autoload :Uploads
+    autoload :Downloads
+    autoload :Persistence
+    autoload :Timeout
+    autoload :FileList
+  end
+
+  module Connection
+    extend ActiveSupport::Autoload
+
+    autoload :Base
+    autoload :Download
+    autoload :Hub
+    autoload :Search
+    autoload :Upload
+  end
+
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification 
+name: fargo
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Alex Crichton
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-06 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: libxml-ruby
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: bzip2-ruby
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id003
+description: DC Client
+email: alex@alexcrichton.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/fargo.rb
+- lib/fargo/client.rb
+- lib/fargo/connection/base.rb
+- lib/fargo/connection/download.rb
+- lib/fargo/connection/hub.rb
+- lib/fargo/connection/search.rb
+- lib/fargo/connection/upload.rb
+- lib/fargo/parser.rb
+- lib/fargo/publisher.rb
+- lib/fargo/search.rb
+- lib/fargo/search_result.rb
+- lib/fargo/server.rb
+- lib/fargo/supports/chat.rb
+- lib/fargo/supports/downloads.rb
+- lib/fargo/supports/file_list.rb
+- lib/fargo/supports/nick_list.rb
+- lib/fargo/supports/persistence.rb
+- lib/fargo/supports/searches.rb
+- lib/fargo/supports/timeout.rb
+- lib/fargo/supports/uploads.rb
+- lib/fargo/utils.rb
+- lib/fargo/version.rb
+has_rdoc: true
+homepage: http://github.com/alexcrichton/fargo
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 1373483426740815041
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 1373483426740815041
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A client for the DC protocol
+test_files: []
+