cancer 0.1.0.a1

data/lib/cancer/adapters/em.rb

@@ -0,0 +1,88 @@
+
+require 'rubygems'
+require 'eventmachine'
+require 'net/dns/resolver'
+require 'net/dns/rr/srv'
+
+module Cancer
+  module Adapters
+    class EM < Cancer::Adapter
+      
+      attr_accessor :lock
+      
+      def initialize(stream, options={})
+        super
+        @options[:port] = (@options[:port] || @options[:default_port] || 5222)
+        unless @options[:server]
+          servers = lookup_xmpp_servers_for(
+            @options[:jid].domain,
+            @options[:port])
+          @options[:server] = servers.first[0]
+          @options[:port]   = servers.first[1]
+        end
+        @lock = Cancer::Lock.new
+      end
+      
+      def connect
+        @connection = EventMachine.connect(@options[:server], @options[:port], Connection, self)
+      end
+      
+      def send(data)
+        @connection.send_data(data.to_s)
+      end
+      
+      def received_data(data)
+        @stream.received_data(data)
+      end
+        
+      def start_tls?
+        true
+      end
+      
+      def start_tls
+        EventMachine.defer { @connection.start_tls(:verify_peer => false) }
+        @lock.wait!
+      end
+        
+      def disconnect
+        EventMachine.defer { @connection.close_connection }
+      end
+      
+    private
+      
+      def lookup_xmpp_servers_for(domain, default_port)
+        servers = Net::DNS::Resolver.start("_xmpp-client._tcp.#{domain}.", Net::DNS::SRV).answer
+        
+        servers.sort! do |a,b|
+          (a.priority != b.priority) ? (a.priority <=> b.priority) : (b.weight <=> a.weight)
+        end
+        
+        servers.collect! do |record|
+          [record.host.to_s, record.port.to_i, :match]
+        end
+        
+        if servers.empty?
+          servers = [[domain, default_port, :fallback]]
+        end
+        
+        servers
+      end
+      
+      class Connection < EventMachine::Connection
+        def initialize(adapter)
+          @adapter = adapter
+          super()
+        end
+        
+        def ssl_handshake_completed
+          @adapter.lock.continue!
+        end
+        
+        def receive_data data
+          @adapter.received_data(data)
+        end
+      end
+      
+    end
+  end
+end

data/lib/cancer/adapters/socket.rb

@@ -0,0 +1,122 @@
+
+require 'rubygems'
+require 'socket'
+require 'openssl/nonblock'
+require 'net/dns/resolver'
+require 'net/dns/rr/srv'
+
+module Cancer
+  module Adapters
+    class Socket < Cancer::Adapter
+      
+      def initialize(stream, options={})
+        super
+        @options[:port] = (@options[:port] || @options[:default_port] || 5222)
+        unless @options[:server]
+          servers = lookup_xmpp_servers_for(
+            @options[:jid].domain,
+            @options[:port])
+          @options[:server] = servers.first[0]
+          @options[:port]   = servers.first[1]
+        end
+        @mutex  = Mutex.new
+      end
+      
+      def connect
+        @socket = TCPSocket.open(@options[:server], @options[:port])
+        start_parsing
+      end
+      
+      def start_tls?
+        true
+      end
+      
+      def start_tls
+        @mutex.synchronize do
+          
+          ssl_socket = OpenSSL::SSL::SSLSocket.new(@socket, OpenSSL::SSL::SSLContext.new)
+          
+          class << ssl_socket
+            alias_method :recv_nonblock, :read_nonblock
+          end
+          
+          begin
+            ssl_socket.connect_nonblock
+          rescue OpenSSL::SSL::ReadAgain
+            IO.select([ssl_socket])
+            retry
+          rescue OpenSSL::SSL::WriteAgain
+            IO.select(nil, [ssl_socket])
+            retry
+          end
+          
+          @normal_socket = @socket
+          @socket = ssl_socket
+          
+        end
+      end
+      
+      def start_parsing
+        @parser_thread = Thread.new do
+          Thread.current.abort_on_exception = true
+          
+          until Thread.current[:stop]
+            begin
+              socket = @mutex.synchronize { @socket }
+              data = socket.recv_nonblock(1024)
+              @stream.received_data(data)
+            rescue Errno::EAGAIN, OpenSSL::SSL::ReadAgain
+              unless IO.select([socket], nil, nil, 3)
+                begin
+                  socket << " "
+                  socket.flush
+                rescue
+                end
+              end
+              retry
+            rescue IOError => e
+              Cancer.logger.fatal(e)
+              break
+            rescue OpenSSL::SSL::SSLError => e
+              Cancer.logger.fatal(e)
+              break
+            end
+          end
+          
+        end
+      end
+      
+      def disconnect
+        @parser_thread[:stop] = true
+        @socket.close
+        @parser_thread.join
+      end
+      
+      def send(data)
+        @socket << data.to_s
+        @socket.flush
+      end
+      
+    private
+      
+      def lookup_xmpp_servers_for(domain, default_port)
+        servers = Net::DNS::Resolver.start("_xmpp-client._tcp.#{domain}.", Net::DNS::SRV).answer
+        
+        servers.sort! do |a,b|
+          (a.priority != b.priority) ? (a.priority <=> b.priority) : (b.weight <=> a.weight)
+        end
+        
+        servers.collect! do |record|
+          [record.host.to_s, record.port.to_i, :match]
+        end
+        
+        if servers.empty?
+          servers = [[domain, default_port, :fallback]]
+        end
+        
+        servers
+      end
+      
+    end
+  end
+end

data/lib/cancer/builder.rb

@@ -0,0 +1,28 @@
+
+require 'delegate'
+
+module Cancer
+  class Builder < DelegateClass(Nokogiri::XML::Builder)
+    
+    extend Cancer::Support
+    
+    def initialize(stream, builder=nil, helpers=nil, &proc)
+      @stream = stream
+      
+      if builder
+        @builder = builder
+        super(@builder)
+        extend helpers  if helpers
+        proc.call(self) if proc
+      else
+        Nokogiri::XML::Builder.new do |builder|
+          @builder = builder
+          super(@builder)
+          extend helpers  if helpers
+          proc.call(self) if proc
+        end
+      end
+    end
+    
+  end
+end

data/lib/cancer/controller.rb

@@ -0,0 +1,32 @@
+
+module Cancer
+  class Controller
+    include Cancer::Events::Eventable
+    extend  Cancer::Support
+    
+    def initialize(stream)
+      @stream = stream
+    end
+    
+    def method_missing(m, *args, &proc)
+      if @stream.respond_to?(m)
+        @stream.__send__(m,*args,&proc)
+      else
+        super
+      end
+    end
+    
+    def self.method_missing(m, *args, &proc)
+      if Cancer::Stream.respond_to?(m)
+        Cancer::Stream.__send__(m,*args,&proc)
+      else
+        super
+      end
+    end
+    
+    def send(*args,&proc)
+      @stream.send(*args,&proc)
+    end
+    
+  end
+end

data/lib/cancer/dependencies.rb

@@ -0,0 +1,187 @@
+require 'tsort'
+
+module Cancer
+  module Dependencies
+    
+    def self.included(base)
+      base.extend(Cancer::Dependencies::ClassMethods)
+    end
+    
+    module ClassMethods
+      
+      def dependency(node, options={})
+        if options[:weak]
+          if options[:reverse]
+            weak_reverse_dependecies.push(node)
+          else
+            weak_dependecies.push(node)
+          end
+        else
+          if options[:reverse]
+            strong_reverse_dependecies.push(node)
+          else
+            strong_dependecies.push(node)
+          end
+        end
+      end
+      
+      def strong_dependecies
+        @strong_dependecies ||= begin
+          if respond_to?(:superclass) and superclass.respond_to?(:strong_dependecies)
+            superclass.strong_dependecies.dup
+          else
+            []
+          end
+        end
+      end
+      
+      def weak_dependecies
+        @weak_dependecies ||= begin
+          if respond_to?(:superclass) and superclass.respond_to?(:weak_dependecies)
+            superclass.weak_dependecies.dup
+          else
+            []
+          end
+        end
+      end
+      
+      def strong_reverse_dependecies
+        @strong_reverse_dependecies ||= begin
+          if respond_to?(:superclass) and superclass.respond_to?(:strong_reverse_dependecies)
+            superclass.strong_reverse_dependecies.dup
+          else
+            []
+          end
+        end
+      end
+      
+      def weak_reverse_dependecies
+        @weak_reverse_dependecies ||= begin
+          if respond_to?(:superclass) and superclass.respond_to?(:weak_reverse_dependecies)
+            superclass.weak_reverse_dependecies.dup
+          else
+            []
+          end
+        end
+      end
+      
+    end
+    
+    class MissingDependency < RuntimeError
+      def initialize(name, dep)
+        super("Missing dependency #{dep} for #{name}")
+      end
+    end
+    
+    class Resolver
+      
+      def initialize(options={})
+        @options = { :allow_reverse => true }.merge(options)
+        @defined_nodes = {}
+      end
+      
+      def on_missing_strong_dependency(&proc)
+        @dependency_finder = proc if proc
+      end
+      
+      def add_node(name, desc)
+        unless desc.ancestors.include?(Cancer::Dependencies)
+          raise ArgumentError, 'not a Cancer::Dependency'
+        end
+        
+        if @resolving
+          @dependency_added = true
+          @unprocessed_nodes.push(name)
+        end
+        
+        @defined_nodes[name] = [
+          desc.strong_dependecies.dup,
+          desc.strong_reverse_dependecies.dup,
+          desc.weak_dependecies.dup,
+          desc.weak_reverse_dependecies.dup
+        ]
+      end
+      
+      def sort(*enabled_nodes)
+        @resolving = true
+        
+        enabled_nodes = enabled_nodes.flatten.compact
+        (@defined_nodes.keys - enabled_nodes).each do |name|
+          @defined_nodes.delete(name)
+        end
+        
+        @unprocessed_nodes = @defined_nodes.keys.dup
+        while name = @unprocessed_nodes.shift
+          dependencies = @defined_nodes[name]
+          if dependencies.size == 4
+            
+            dependencies[0].each do |dep|
+              unless @defined_nodes.key? dep
+                @dependency_added = false
+                @dependency_finder.call(dep) if @dependency_finder
+                raise MissingDependency.new(name, dep) unless @dependency_added
+              end
+            end
+            
+            if @options[:allow_reverse]
+              dependencies[1].each do |dep|
+                if node = @defined_nodes[dep]
+                  node[0].push name
+                else
+                  @dependency_added = false
+                  @dependency_finder.call(dep) if @dependency_finder
+                  if @dependency_added and node = @defined_nodes[dep]
+                      node[0].push name
+                  else
+                    raise MissingDependency.new(name, dep)
+                  end
+                end
+              end
+            end
+            
+          end
+        end
+        
+        @unprocessed_nodes = @defined_nodes.keys.dup
+        while name = @unprocessed_nodes.shift
+          dependencies = @defined_nodes[name]
+          if dependencies.size == 4
+            
+            dependencies[2].each do |dep|
+              if @defined_nodes.key? dep
+                dependencies[0].push dep
+              end
+            end
+            
+            if @options[:allow_reverse]
+              dependencies[3].each do |dep|
+                if node = @defined_nodes[dep]
+                  node[0].push name
+                end
+              end
+            end
+            
+          end
+        end
+        
+        @unprocessed_nodes = nil
+        @resolving = false
+        tsort
+      end
+      
+    private
+      
+      include TSort
+      
+      def tsort_each_node(&proc)
+        @defined_nodes.each_key(&proc)
+      end
+      
+      def tsort_each_child(node, &block)
+        @defined_nodes[node][0].each(&block)
+      end
+      
+    end
+    
+  end
+end