distribustream 0.1.0 → 0.2.0

data/lib/pdtp/common/packet.rb

@@ -0,0 +1,106 @@
+#--
+# Copyright (C) 2006-07 ClickCaster, Inc. (info@clickcaster.com)
+# All rights reserved.  See COPYING for permissions.
+# 
+# This source file is distributed as part of the 
+# DistribuStream file transfer system.
+#
+# See http://distribustream.rubyforge.org/
+#++
+
+require 'rubygems'
+require 'eventmachine'
+
+module PDTP
+  # EventMachine connection adapter for sending and receiving frames with 16-bit length prefixes
+  class Packet < EventMachine::Connection
+    # Class for processing length prefixes in packet frames
+    class Prefix
+      attr_reader :length
+      
+      def initialize
+        # Constant at 2 bytes, but expandable if we desire
+        @length = 2
+        reset!
+      end
+      
+      def read?
+        @length == @read
+      end
+      
+      def append(data)
+        toread = @length - @read
+        new_data = data[0..(toread - 1)]
+        
+        @data << new_data        
+        @read += new_data.size
+        return nil unless @read == @length
+        
+        @size = @data.unpack('n').first
+        result = data[toread..data.size]
+        
+        return nil if result.nil? or result.empty?
+        result
+      end
+      
+      def size
+        return false unless read?
+        @size
+      end
+      
+      def reset!
+        @size = nil
+        @read = 0
+        @data = ''        
+      end
+    end
+    
+    def initialize(*args)
+      super
+      @prefix = Prefix.new
+      @buffer = ''
+    end
+    
+    # Callback for processing incoming frames
+    def receive_data(data)
+      # Read data and append it to the length prefix unless it's already been read
+      data = @prefix.append(data) unless @prefix.read?
+      return if data.nil?
+      
+      # If we've read the prefix, append the data
+      @buffer << data
+      
+      # Don't do anything until we receive the specified amount of data
+      return unless @buffer.size >= @prefix.size
+      
+      # Extract the specified amount of data and process it
+      data = @buffer[0..(@prefix.size - 1)]      
+      receive_packet data
+      
+      # Store any remaining data
+      remainder = @buffer[@prefix.size..@buffer.size]
+      
+      # Reset the prefix and buffer since we've received a whole frame
+      @prefix.reset!
+      @buffer = ''
+      
+      # Don't do anything if there's no more data
+      return if remainder.nil? or remainder.empty?
+      
+      # Otherwise continue processing the data
+      receive_data remainder
+    end
+    
+    # Stub for receiving a frame
+    def receive_packet(packet)
+    end
+    
+    # Send a packet with a specified length prefix
+    def send_packet(data)
+      length = data.size
+      raise ArgumentError, 'oversize packet' if length >= 256**@prefix.length
+      
+      send_data [length].pack('n') << data
+    end
+  end
+end

data/lib/pdtp/common/protocol.rb

@@ -11,7 +11,6 @@
 require 'rubygems'
 require 'eventmachine'
 require 'thread'
-require 'uri'
 require 'ipaddr'
 
 begin
@@ -20,6 +19,8 @@ rescue LoadError
   require 'json'
 end
 
+require File.dirname(__FILE__) + '/packet.rb'
+
 module PDTP
   PROTOCOL_DEBUG=true
 
@@ -30,9 +31,8 @@ module PDTP
   end
 
   # EventMachine handler class for the PDTP protocol
-  class Protocol < EventMachine::Protocols::LineAndTextProtocol
+  class Protocol < PDTP::Packet
     @@num_connections = 0
-    @@listener = nil
     @@message_params = nil
     @connection_open = false
 
@@ -40,15 +40,10 @@ module PDTP
       @connection_open
     end
 
-    #sets the listener class (Server or Client)
-    def self.listener=(listener)
-      @@listener = listener
-    end
-
-    def initialize(*args)
+    def initialize(data)
       user_data = nil
       @mutex = Mutex.new
-      super
+      super data
     end
 
     #called by EventMachine after a connection has been established
@@ -64,7 +59,7 @@ module PDTP
 
       @@num_connections += 1
       @connection_open = true
-      @@listener.connection_created(self) if @@listener.respond_to?(:connection_created)
+      connection_created if respond_to? :connection_created
     end
 
     attr_accessor :user_data #users of this class may store arbitrary data here
@@ -79,30 +74,25 @@ module PDTP
       end
     end
 
-    #override this in a child class to handle messages
-    def receive_message(command, message)
-      @@listener.dispatch_message command, message, self 
-    end
-
     #debug routine: returns id of remote peer on this connection
     def remote_peer_id
       ret = user_data.client_id rescue nil
       ret || 'NOID'
     end
 
-    #called for each line of text received over the wire
+    #called for each packet of data received over the wire
     #parses the JSON message and dispatches the message
-    def receive_line line
+    def receive_packet(packet)
       begin
-        line.chomp!
-        @@log.debug "(#{remote_peer_id}) recv: " + line
-        message = JSON.parse(line) rescue nil
-        raise ProtocolError.new("JSON couldn't parse: #{line}") if message.nil?
+        packet.chomp!
+        @@log.debug "(#{remote_peer_id}) recv: " + packet
+        message = JSON.parse(packet) rescue nil
+        raise ProtocolError.new("JSON couldn't parse: #{packet}") if message.nil?
         Protocol.validate_message message
         
         command, options = message
         hash_to_range command, options
-        receive_message command, options
+        receive_message(command, options) if respond_to? :receive_message
       rescue ProtocolError => e
         @@log.warn "(#{remote_peer_id}) PROTOCOL ERROR: #{e.to_s}"
         @@log.debug e.backtrace.join("\n")
@@ -166,17 +156,17 @@ module PDTP
       # Second entry is an options hash/object
       message = [command.to_s, opts]
       
-      @mutex.synchronize do
+      #@mutex.synchronize do
         outstr = JSON.unparse(message) + "\n"
         @@log.debug "(#{remote_peer_id}) send: #{outstr.chomp}"
-        send_data outstr  
-      end
+        send_packet outstr  
+      #end
     end
 
     #called by EventMachine when a connection is closed
     def unbind
       @@num_connections -= 1
-      @@listener.connection_destroyed(self) if @@listener.respond_to?(:connection_destroyed)
+      connection_destroyed if respond_to? :connection_destroyed
       @connection_open = false
     end
 
@@ -249,7 +239,7 @@ module PDTP
       mp = {}
 
       #must be the first message the client sends
-      mp["client_info"]={
+      mp["register"]={
         "client_id"=>:string,
         "listen_port"=>:int                  
       }
@@ -277,7 +267,7 @@ module PDTP
         "url"=>:url,
         "range"=>:range,
         "peer_id"=>:string,
-        "is_authorized"=>:bool
+        "authorized"=>:bool
       }
 
       mp["request"]={

data/lib/pdtp/server/client_info.rb

@@ -8,133 +8,135 @@
 # See http://distribustream.rubyforge.org/
 #++
 
-require File.dirname(__FILE__)+'/trust.rb'
+require File.dirname(__FILE__) + '/trust'
 
 module PDTP
-  #stores information about a single connected client
-  class ClientInfo
-    attr_accessor :chunk_info, :trust
-    attr_accessor :listen_port, :client_id
-    attr_accessor :transfers
-    
-    def initialize
-      @chunk_info=ChunkInfo.new
-      @listen_port=6000 #default
-      @trust=Trust.new
-      @transfers=Hash.new
-    end
+  class Server
+    #stores information about a single connected client
+    class ClientInfo
+      attr_accessor :chunk_info, :trust
+      attr_accessor :listen_port, :client_id
+      attr_accessor :transfers
 
-    # returns true if this client wants the server to spawn a transfer for it
-    def wants_download?
-      transfer_state_allowed=5
-      total_allowed=10
-      transferring=0
-      @transfers.each do |key, t|
-        transferring=transferring+1 if t.verification_asked
-        return false if transferring >= transfer_state_allowed
+      def initialize
+        @chunk_info=ChunkInfo.new
+        @listen_port=6000 #default
+        @trust=Trust.new
+        @transfers=Hash.new
       end
 
-      @transfers.size < total_allowed
-    end 
-
-    #this could have a different definition, but it works fine to use wants_download?
-    alias_method :wants_upload?, :wants_download?
-    
-    #returns a list of all the stalled transfers this client is a part of
-    def get_stalled_transfers
-      stalled=[]
-      timeout=20.0
-      now=Time.now
-      @transfers.each do |key,t|
-        #only delete if we are the acceptor to prevent race conditions
-        next if t.acceptor.user_data != self 
-        if now-t.creation_time > timeout and not t.verification_asked
-          stalled << t
+      # returns true if this client wants the server to spawn a transfer for it
+      def wants_download?
+        transfer_state_allowed=5
+        total_allowed=10
+        transferring=0
+        @transfers.each do |key, t|
+          transferring=transferring+1 if t.verification_asked
+          return false if transferring >= transfer_state_allowed
         end
-      end
-      stalled
-    end
-  end
 
-  #stores information about the chunks requested or provided by a client
-  class ChunkInfo
-    def initialize
-      @files={}
-    end
+        @transfers.size < total_allowed
+      end 
 
-    #each chunk can either be provided, requested, transfer, or none
-    def provide(filename,range); set(filename,range,:provided) ; end
-    def unprovide(filename,range); set(filename,range, :none); end
-    def request(filename,range); set(filename,range, :requested); end
-    def unrequest(filename,range); set(filename,range, :none); end
-    def transfer(filename,range); set(filename,range, :transfer); end
-
-    def provided?(filename,chunk); get(filename,chunk) == :provided; end
-    def requested?(filename,chunk); get(filename,chunk) == :requested; end
-
-    #returns a high priority requested chunk
-    def high_priority_chunk
-      #right now return any chunk
-      @files.each do |name,file|
-        file.each_index do |i|
-          return [name,i] if file[i]==:requested
-        end
-      end  
-      
-      nil
-    end
+      #this could have a different definition, but it works fine to use wants_download?
+      alias_method :wants_upload?, :wants_download?
 
-    #calls a block for each chunk of the specified type
-    def each_chunk_of_type(type)
-      @files.each do |name,file|
-        file.each_index do |i|
-          yield(name,i) if file[i]==type
+      #returns a list of all the stalled transfers this client is a part of
+      def get_stalled_transfers
+        stalled=[]
+        timeout=20.0
+        now=Time.now
+        @transfers.each do |key,t|
+          #only delete if we are the acceptor to prevent race conditions
+          next if t.acceptor.user_data != self 
+          if now-t.creation_time > timeout and not t.verification_asked
+            stalled << t
+          end
         end
-      end 
+        stalled
+      end
     end
 
-    class FileStats
-      attr_accessor :file_chunks, :chunks_requested,:url
-      attr_accessor :chunks_provided, :chunks_transferring
-      
+    #stores information about the chunks requested or provided by a client
+    class ChunkInfo
       def initialize
-        @url=""
-        @file_chunks=0
-        @chunks_requested=0
-        @chunks_provided=0
-        @chunks_transferring=0
+        @files={}
       end
-    end
 
-    #returns an array of FileStats objects for debug output
-    def get_file_stats
-      stats=[]
-      @files.each do |name,file|
-        fs=FileStats.new
-        fs.file_chunks=file.size
-        fs.url=name
-        file.each do |chunk|
-          fs.chunks_requested+=1 if chunk==:requested
-          fs.chunks_provided+=1 if chunk==:provided
-          fs.chunks_transferring+=1 if chunk==:transfer
+      #each chunk can either be provided, requested, transfer, or none
+      def provide(filename,range); set(filename,range,:provided) ; end
+      def unprovide(filename,range); set(filename,range, :none); end
+      def request(filename,range); set(filename,range, :requested); end
+      def unrequest(filename,range); set(filename,range, :none); end
+      def transfer(filename,range); set(filename,range, :transfer); end
+
+      def provided?(filename,chunk); get(filename,chunk) == :provided; end
+      def requested?(filename,chunk); get(filename,chunk) == :requested; end
+
+      #returns a high priority requested chunk
+      def high_priority_chunk
+        #right now return any chunk
+        @files.each do |name,file|
+          file.each_index do |i|
+            return [name,i] if file[i]==:requested
+          end
+        end  
+
+        nil
+      end
+
+      #calls a block for each chunk of the specified type
+      def each_chunk_of_type(type)
+        @files.each do |name,file|
+          file.each_index do |i|
+            yield(name,i) if file[i]==type
+          end
+        end 
+      end
+
+      class FileStats
+        attr_accessor :file_chunks, :chunks_requested,:url
+        attr_accessor :chunks_provided, :chunks_transferring
+
+        def initialize
+          @url=""
+          @file_chunks=0
+          @chunks_requested=0
+          @chunks_provided=0
+          @chunks_transferring=0
         end
-        stats << fs
       end
-      
-      stats 
-    end
 
-    #########
-    protected
-    #########
+      #returns an array of FileStats objects for debug output
+      def get_file_stats
+        stats=[]
+        @files.each do |name,file|
+          fs=FileStats.new
+          fs.file_chunks=file.size
+          fs.url=name
+          file.each do |chunk|
+            fs.chunks_requested+=1 if chunk==:requested
+            fs.chunks_provided+=1 if chunk==:provided
+            fs.chunks_transferring+=1 if chunk==:transfer
+          end
+          stats << fs
+        end
 
-    def get(filename,chunk)
-      @files[filename][chunk] rescue :neither
-    end
+        stats 
+      end
+
+      #########
+      protected
+      #########
 
-    def set(filename,range,state)
-      chunks=@files[filename]||=Array.new
-      range.each { |i| chunks[i]=state }
+      def get(filename,chunk)
+        @files[filename][chunk] rescue :neither
+      end
+
+      def set(filename,range,state)
+        chunks=@files[filename]||=Array.new
+        range.each { |i| chunks[i]=state }
+      end
     end
   end
 end

data/lib/pdtp/server/connection.rb

@@ -0,0 +1,35 @@
+#--
+# Copyright (C) 2006-07 ClickCaster, Inc. (info@clickcaster.com)
+# All rights reserved.  See COPYING for permissions.
+# 
+# This source file is distributed as part of the 
+# DistribuStream file transfer system.
+#
+# See http://distribustream.rubyforge.org/
+#++
+
+require File.dirname(__FILE__) + '/../common/protocol'
+
+module PDTP
+  class Server
+    class Connection < PDTP::Protocol
+      attr_accessor :server
+      attr_accessor :user_data
+      
+      def connection_completed
+        raise(RuntimeError, 'server was never initialized') unless @server
+        @server.connection_created self
+      end
+      
+      def connection_destroyed
+        raise(RuntimeError, 'server was never initialized') unless @server
+        @server.connection_destroyed self
+      end
+      
+      def receive_message(command, message)
+        raise(RuntimeError, 'server was never initialized') unless @server
+        @server.dispatch_message command, message, self
+      end
+    end
+  end
+end