archipelago 0.1.0

data/lib/disco.rb

@@ -0,0 +1,548 @@
+# Archipelago - a distributed computing toolkit for ruby
+# Copyright (C) 2006  Martin Kihlgren <zond at troja dot ath dot cx>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+require 'socket'
+require 'thread'
+require 'ipaddr'
+require 'pp'
+require 'current'
+require 'drb'
+require 'set'
+
+module Archipelago
+
+  module Disco
+
+    #
+    # Default address to use.
+    #
+    ADDRESS = "234.2.4.2"
+    #
+    # Default port to use.
+    #
+    PORT = 25242
+    #
+    # Default port range to use for unicast.
+    #
+    UNIPORTS = 25243..26243
+    #
+    # Default lookup timeout.
+    #
+    LOOKUP_TIMEOUT = 10
+    #
+    # Default initial pause between resending lookup queries.
+    # Will be doubled for each resend.
+    #
+    INITIAL_LOOKUP_STANDOFF = 0.1
+    #
+    # Default pause between trying to validate all services we
+    # know about.
+    #
+    VALIDATION_INTERVAL = 60
+    #
+    # Only save stuff that we KNOW we want.
+    #
+    THRIFTY_CACHING = true
+    #
+    # Only reply to the one actually asking about a service.
+    #
+    THRIFTY_REPLYING = true
+    #
+    # Dont send on publish, only on query.
+    #
+    THRIFTY_PUBLISHING = false
+    
+    #
+    # A module to simplify publishing services.
+    #
+    # If you include it you can use the publish! method
+    # at your convenience.
+    #
+    # If you want to customize the publishing related behaviour you can
+    # call <b>initialize_publishable</b> with a Hash of options.
+    #
+    # See Archipelago::Treasure::Chest or Archipelago::Tranny::Manager for examples.
+    #
+    # It will store the service_id of this service in a directory beside this
+    # file (publishable.rb) named as the class you include into unless you
+    # define <b>@persistence_provider</b> before you call <b>initialize_publishable</b>.
+    #
+    module Publishable
+
+      #
+      # Will initialize this instance with @service_description and @jockey_options
+      # and merge these with the optionally given <i>:service_description</i> and
+      # <i>:jockey_options</i>.
+      #
+      def initialize_publishable(options = {})
+        @service_description = {
+          :service_id => service_id,
+          :validator => DRbObject.new(self),
+          :service => DRbObject.new(self),
+          :class => self.class.name
+        }.merge(options[:service_description] || {})
+        @jockey_options = options[:jockey_options] || {}
+      end
+
+      #
+      # Create an Archipelago::Disco::Jockey for this instance using @jockey_options
+      # or optionally given <i>:jockey_options</i>.
+      #
+      # Will publish this service using @service_description or optionally given
+      # <i>:service_description</i>.
+      #
+      def publish!(options = {})
+        @jockey ||= Archipelago::Disco::Jockey.new(@jockey_options.merge(options[:jockey_options] || {}))
+        @jockey.publish(Archipelago::Disco::Record.new(@service_description.merge(options[:service_description] || {})))
+      end
+
+      #
+      # We are always valid if we are able to reply.
+      #
+      def valid?
+        true
+      end
+      
+      #
+      # Returns our semi-unique id so that we can be found again.
+      #
+      def service_id
+        #
+        # The provider of happy magic persistent hashes of different kinds.
+        #
+        @persistence_provider ||= Archipelago::Hashish::BerkeleyHashishProvider.new(Pathname.new(File.expand_path(__FILE__)).parent.join(self.class.name + ".db"))
+        #
+        # Stuff that didnt fit in any of the other databases.
+        #
+        @metadata ||= @persistence_provider.get_hashish("metadata")
+        service_id = @metadata["service_id"]
+        unless service_id
+          host = "#{Socket::gethostbyname(Socket::gethostname)[0]}" rescue "localhost"
+          service_id = @metadata["service_id"] ||= Digest::SHA1.hexdigest("#{host}:#{Time.new.to_f}:#{self.object_id}:#{rand(1 << 32)}")
+        end
+        return service_id
+      end
+
+    end
+
+    #
+    # A mock validator to be used for dumb systems that dont want
+    # to validate.
+    #
+    class MockValidator
+      def valid?
+        true
+      end
+    end
+
+    #
+    # A Hash-like description of a service.
+    #
+    class ServiceDescription
+      IGNORABLE_ATTRIBUTES = Set[:unicast_reply]
+      attr_reader :attributes
+      #
+      # Initialize this service description with a hash
+      # that describes its attributes.
+      #
+      def initialize(hash = {})
+        @attributes = hash
+      end
+      #
+      # Forwards as much as possible to our Hash.
+      #
+      def method_missing(meth, *args, &block)
+        if @attributes.respond_to?(meth)
+          if block
+            @attributes.send(meth, *args, &block)
+          else
+            @attributes.send(meth, *args)
+          end
+        else
+          super(*args)
+        end
+      end
+      #
+      # Returns whether this ServiceDescription matches the given +match+.
+      #
+      def matches?(match)
+        match.each do |key, value|
+          unless IGNORABLE_ATTRIBUTES.include?(key)
+            return false unless @attributes.include?(key) && (value.nil? || @attributes[key] == value)
+          end
+        end
+        true
+      end
+    end
+
+    #
+    # A class used to query the Disco network for services.
+    #
+    class Query < ServiceDescription
+    end
+
+    #
+    # A class used to define an existing service.
+    #
+    class Record < ServiceDescription
+      #
+      # Initialize this Record with a hash that must contain an <i>:service_id</i> and a <i>:validator</i>.
+      #
+      def initialize(hash)
+        raise "Record must have an :service_id" unless hash.include?(:service_id)
+        raise "Record must have a :validator" unless hash.include?(:validator)
+        super(hash)
+      end
+      #
+      # Returns whether this service is still valid.
+      #
+      def valid?
+        begin
+          self[:validator].valid?
+        rescue DRb::DRbError => e
+          false
+        end
+      end
+    end
+
+    #
+    # A container of services.
+    #
+    class ServiceLocker
+      attr_reader :hash
+      include Archipelago::Current::Synchronized
+      def initialize(hash = nil)
+        super
+        @hash = hash || {}
+      end
+      #
+      # Merge this locker with another.
+      #
+      def merge(sd)
+        rval = @hash.clone
+        rval.merge!(sd.hash)
+        ServiceLocker.new(rval)
+      end
+      #
+      # Forwards as much as possible to our Hash.
+      #
+      def method_missing(meth, *args, &block)
+        if @hash.respond_to?(meth)
+          synchronize do
+            if block
+              @hash.send(meth, *args, &block)
+            else
+              @hash.send(meth, *args)
+            end
+          end
+        else
+          super(*args)
+        end
+      end
+      #
+      # Find all containing services matching +match+.
+      #
+      def get_services(match)
+        rval = ServiceLocker.new
+        self.each do |service_id, service_data|
+          rval[service_id] = service_data if service_data.matches?(match) && service_data.valid?
+        end
+        return rval
+      end
+      #
+      # Remove all non-valid services.
+      #
+      def validate!
+        self.clone.each do |service_id, service_data|
+          self.delete(service_id) unless service_data.valid?
+        end
+      end
+    end
+
+    #
+    # The main discovery class used to both publish and lookup services.
+    #
+    class Jockey
+      
+      attr_reader :new_service_semaphore
+      
+      #
+      # Will create a Jockey service running on <i>:address</i> and <i>:port</i> or
+      # ADDRESS and PORT if none are given.
+      #
+      # Will the first available unicast port within <i>:uniports</i> or if not given UNIPORTS for receiving unicast messages.
+      #
+      # Will have a default <i>:lookup_timeout</i> of LOOKUP_TIMEOUT, a default
+      # <i>:initial_lookup_standoff</i> of INITIAL_LOOKUP_STANDOFF and a default
+      # <i>:validation_interval</i> of VALIDATION_INTERVAL.
+      #
+      # Will only cache (and validate, which saves network traffic) stuff
+      # that has been looked up before if <i>:thrifty_caching</i>, or THRIFTY_CACHING if not given.
+      #
+      # Will only reply to the one that sent out the query (and therefore save lots of network traffic)
+      # if <i>:thrifty_replying</i>, or THRIFTY_REPLYING if not given.
+      #
+      # Will send out a multicast when a new service is published unless <i>:thrifty_publishing</i>, or
+      # THRIFTY_PUBLISHING if not given.
+      #
+      # Will reply to all queries to which it has matching local services with a unicast message if <i>:thrifty_replying</i>,
+      # or if not given THRIFTY_REPLYING. Otherwise will reply with multicasts.
+      #
+      def initialize(options = {})
+        @thrifty_caching = options.include?(:thrifty_caching) ? options[:thrifty_caching] : THRIFTY_CACHING
+        @thrifty_replying = options.include?(:thrifty_replying) ? options[:thrifty_replying] : THRIFTY_REPLYING
+        @thrifty_publishing = options.include?(:thrifty_publishing) ? options[:thrifty_publishing] : THRIFTY_PUBLISHING
+        @lookup_timeout = options[:lookup_timeout] || LOOKUP_TIMEOUT
+        @initial_lookup_standoff = options[:initial_lookup_standoff] || INITIAL_LOOKUP_STANDOFF
+
+        @remote_services = ServiceLocker.new
+        @local_services = ServiceLocker.new
+        @subscribed_services = Set.new
+
+        @incoming = Queue.new
+        @outgoing = Queue.new
+        
+        @new_service_semaphore = MonitorMixin::ConditionVariable.new(Archipelago::Current::Lock.new)
+        
+        @listener = UDPSocket.new
+        @unilistener = UDPSocket.new
+        
+        @listener.setsockopt(Socket::IPPROTO_IP, 
+                             Socket::IP_ADD_MEMBERSHIP, 
+                             IPAddr.new(options[:address] || ADDRESS).hton + Socket.gethostbyname("0.0.0.0")[3])
+        
+        @listener.setsockopt(Socket::SOL_SOCKET, 
+                             Socket::SO_REUSEADDR, 
+                             true)
+        begin
+          @listener.setsockopt(Socket::SOL_SOCKET, 
+                               Socket::SO_REUSEPORT, 
+                               true)
+        rescue
+          # /moo
+        end
+        @listener.bind('', options[:port] || PORT)
+
+        uniports = options[:uniports] || UNIPORTS
+        this_port = uniports.min
+        begin
+          @unilistener.bind('', this_port)
+        rescue Errno::EADDRINUSE => e
+          if this_port < uniports.max
+            this_port += 1
+            retry
+          else
+            raise e
+          end
+        end
+        @unicast_address = "#{Socket::gethostbyname(Socket::gethostname)[0]}:#{this_port}" rescue "localhost:#{this_port}"
+        
+        @sender = UDPSocket.new
+        @sender.connect(options[:address] || ADDRESS, options[:port] || PORT)
+
+        @unisender = UDPSocket.new
+
+        start_listener
+        start_unilistener
+        start_shouter
+        start_picker
+        start_validator(options[:validation_interval] || VALIDATION_INTERVAL)
+      end
+
+      #
+      # Stops all the threads in this instance.
+      #
+      def stop
+        @listener_thread.kill
+        @unilistener_thread.kill
+        @shouter_thread.kill
+        @picker_thread.kill
+        @validator_thread.kill
+      end
+
+      #
+      # Lookup any services matching +match+, optionally with a +timeout+.
+      #
+      # Will immediately return if we know of matching and valid services,
+      # will otherwise send out regular Queries and return as soon as
+      # matching services are found, or when the +timeout+ runs out.
+      #
+      def lookup(match, timeout = @lookup_timeout)
+        match[:unicast_reply] = @unicast_address
+        @subscribed_services << match if @thrifty_caching
+        standoff = @initial_lookup_standoff
+
+        @outgoing << [nil, match]
+        known_services = @remote_services.get_services(match).merge(@local_services.get_services(match))
+        return known_services unless known_services.empty?
+
+        @new_service_semaphore.wait(standoff)
+        standoff *= 2
+        
+        t = Time.new
+        while Time.new < t + timeout
+          known_services = @remote_services.get_services(match).merge(@local_services.get_services(match))
+          return known_services unless known_services.empty?
+
+          @new_service_semaphore.wait(standoff)
+          standoff *= 2
+
+          @outgoing << [nil, match]
+        end
+
+        ServiceLocker.new
+      end
+
+      #
+      # Record the given +service+ and broadcast about it.
+      #
+      def publish(service)
+        if service.valid?
+          @local_services[service[:service_id]] = service
+          @new_service_semaphore.broadcast
+          unless @thrifty_publishing
+            @outgoing << [nil, service]
+          end
+        end
+      end
+
+      private
+
+      #
+      # Start the validating thread.
+      #
+      def start_validator(validation_interval)
+        @validator_thread = Thread.new do
+          loop do
+            begin
+              @local_services.validate!
+              @remote_services.validate!
+              sleep(validation_interval)
+            rescue Exception => e
+              puts e
+              pp e.backtrace
+            end
+          end
+        end
+      end
+
+      #
+      # Start the thread sending Records and Queries
+      #
+      def start_shouter
+        @shouter_thread = Thread.new do
+          loop do
+            begin
+              recipient, data = @outgoing.pop
+              if recipient
+                address, port = recipient.split(/:/)
+                @unisender.send(Marshal.dump(data), 0, address, port.to_i)
+              else
+                begin
+                  @sender.write(Marshal.dump(data))
+                rescue Errno::ECONNREFUSED => e
+                  retry
+                end
+              end
+            rescue Exception => e
+              puts e
+              pp e.backtrace
+            end
+          end
+        end
+      end
+
+      #
+      # Start the thread receiving Records and Queries
+      #
+      def start_listener
+        @listener_thread = Thread.new do
+          loop do
+            begin
+              @incoming << Marshal.load(@listener.recv(1024))
+            rescue Exception => e
+              puts e
+              pp e.backtrace
+            end
+          end
+        end
+      end
+
+      #
+      # Start the thread receiving Records and Queries
+      # on unicast.
+      #
+      def start_unilistener
+        @unilistener_thread = Thread.new do
+          loop do
+            begin
+              @incoming << Marshal.load(@unilistener.recv(1024))
+            rescue Exception => e
+              puts e
+              pp e.backtrace
+            end
+          end
+        end
+      end
+
+      #
+      # Start the thread picking incoming Records and Queries and
+      # handling them properly
+      #
+      def start_picker
+        @picker_thread = Thread.new do
+          loop do
+            begin
+              data = @incoming.pop
+              if Archipelago::Disco::Query === data
+                @local_services.get_services(data).each do |service_id, service_data|
+                  if @thrifty_replying
+                    @outgoing << [data[:unicast_reply], service_data]
+                  else
+                    @outgoing << [nil, service_data]
+                  end
+                end
+              elsif Archipelago::Disco::Record === data
+                if interesting?(data) && data.valid?
+                  @remote_services[data[:service_id]] = data
+                  @new_service_semaphore.broadcast
+                end
+              end
+            rescue Exception => e
+              puts e
+              pp e.backtrace
+            end
+          end
+        end
+      end
+
+      #
+      # Are we generous in our caching, or have we been
+      # asked about this type of +publish+ before?
+      #
+      def interesting?(publish)
+        @subscribed_services.each do |subscribed|
+          return true if publish.matches?(subscribed)
+        end
+        return !@thrifty_caching
+      end
+
+    end
+
+  end
+
+end