sidekick-client 0.1.0

data/lib/ext/eventmachine-0.12.10/lib/em/protocols/socks4.rb

@@ -0,0 +1,66 @@
+module EventMachine
+  module Protocols
+    # Basic SOCKS v4 client implementation
+    #
+    # Use as you would any regular connection:
+    #
+    # class MyConn < EM::P::Socks4
+    #   def post_init
+    #     send_data("sup")
+    #   end
+    #
+    #   def receive_data(data)
+    #     send_data("you said: #{data}")
+    #   end
+    # end
+    #
+    # EM.connect socks_host, socks_port, MyConn, host, port
+    #
+    class Socks4 < Connection
+      def initialize(host, port)
+        @host = Socket.gethostbyname(host).last
+        @port = port
+        @socks_error_code = nil
+        @buffer = ''
+        setup_methods
+      end
+
+      def setup_methods
+        class << self
+          def post_init; socks_post_init; end
+          def receive_data(*a); socks_receive_data(*a); end
+        end
+      end
+
+      def restore_methods
+        class << self
+          remove_method :post_init
+          remove_method :receive_data
+        end
+      end
+
+      def socks_post_init
+        header = [4, 1, @port, @host, 0].flatten.pack("CCnA4C")
+        send_data(header)
+      end
+
+      def socks_receive_data(data)
+        @buffer << data
+        return  if @buffer.size < 8
+
+        header_resp = @buffer.slice! 0, 8
+        _, r = header_resp.unpack("cc")
+        if r != 90
+          @socks_error_code = r
+          close_connection
+          return
+        end
+
+        restore_methods
+
+        post_init
+        receive_data(@buffer)  unless @buffer.empty?
+      end
+    end
+  end
+end

data/lib/ext/eventmachine-0.12.10/lib/em/protocols/stomp.rb

@@ -0,0 +1,200 @@
+#--
+#
+# Author:: Francis Cianfrocca (gmail: blackhedd)
+# Homepage::  http://rubyeventmachine.com
+# Date:: 15 November 2006
+# 
+# See EventMachine and EventMachine::Connection for documentation and
+# usage examples.
+#
+#----------------------------------------------------------------------------
+#
+# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
+# Gmail: blackhedd
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) 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; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#
+#---------------------------------------------------------------------------
+#
+# 
+# 
+
+module EventMachine
+  module Protocols
+
+    # Implements Stomp (http://docs.codehaus.org/display/STOMP/Protocol).
+    #
+    # == Usage example
+    #
+    #  module StompClient
+    #    include EM::Protocols::Stomp
+    #
+    #    def connection_completed
+    #      connect :login => 'guest', :passcode => 'guest'
+    #    end
+    #
+    #    def receive_msg msg
+    #      if msg.command == "CONNECTED"
+    #        subscribe '/some/topic'
+    #      else
+    #        p ['got a message', msg]
+    #        puts msg.body
+    #      end
+    #    end
+    #  end
+    #
+    #  EM.run{
+    #    EM.connect 'localhost', 61613, StompClient
+    #  }
+    #
+    module Stomp
+      include LineText2
+
+      class Message
+        # The command associated with the message, usually 'CONNECTED' or 'MESSAGE'
+        attr_accessor :command
+        # Hash containing headers such as destination and message-id
+        attr_accessor :header
+        alias :headers :header
+        # Body of the message
+        attr_accessor :body
+
+        def initialize # :nodoc:
+          @header = {}
+          @state = :precommand
+          @content_length = nil
+        end
+        def consume_line line # :nodoc:
+          if @state == :precommand
+            unless line =~ /\A\s*\Z/
+              @command = line
+              @state = :headers
+            end
+          elsif @state == :headers
+            if line == ""
+              if @content_length
+                yield( [:sized_text, @content_length+1] )
+              else
+                @state = :body
+                yield( [:unsized_text] )
+              end
+            elsif line =~ /\A([^:]+):(.+)\Z/
+              k = $1.dup.strip
+              v = $2.dup.strip
+              @header[k] = v
+              if k == "content-length"
+                @content_length = v.to_i
+              end
+            else
+              # This is a protocol error. How to signal it?
+            end
+          elsif @state == :body
+            @body = line
+            yield( [:dispatch] )
+          end
+        end
+      end
+
+      # :stopdoc:
+
+      def send_frame verb, headers={}, body=""
+        ary = [verb, "\n"]
+        headers.each {|k,v| ary << "#{k}:#{v}\n" }
+        ary << "content-length: #{body.to_s.length}\n"
+        ary << "content-type: text/plain; charset=UTF-8\n"
+        ary << "\n"
+        ary << body.to_s
+        ary << "\0"
+        send_data ary.join
+      end
+
+      def receive_line line
+        @stomp_initialized || init_message_reader
+        @stomp_message.consume_line(line) {|outcome|
+          if outcome.first == :sized_text
+            set_text_mode outcome[1]
+          elsif outcome.first == :unsized_text
+            set_delimiter "\0"
+          elsif outcome.first == :dispatch
+            receive_msg(@stomp_message) if respond_to?(:receive_msg)
+            init_message_reader
+          end
+        }
+      end
+
+      def receive_binary_data data
+        @stomp_message.body = data[0..-2]
+        receive_msg(@stomp_message) if respond_to?(:receive_msg)
+        init_message_reader
+      end
+
+      def init_message_reader
+        @stomp_initialized = true
+        set_delimiter "\n"
+        set_line_mode
+        @stomp_message = Message.new
+      end
+
+      # :startdoc:
+
+      # Invoked with an incoming Stomp::Message received from the STOMP server
+      def receive_msg msg
+        # stub, overwrite this in your handler
+      end
+
+      # CONNECT command, for authentication
+      #
+      #  connect :login => 'guest', :passcode => 'guest'
+      #
+      def connect parms={}
+        send_frame "CONNECT", parms
+      end
+
+      # SEND command, for publishing messages to a topic
+      #
+      #  send '/topic/name', 'some message here'
+      #
+      def send destination, body, parms={}
+        send_frame "SEND", parms.merge( :destination=>destination ), body.to_s
+      end
+
+      # SUBSCRIBE command, for subscribing to topics
+      #
+      #  subscribe '/topic/name', false
+      #
+      def subscribe dest, ack=false
+        send_frame "SUBSCRIBE", {:destination=>dest, :ack=>(ack ? "client" : "auto")}
+      end
+
+      # ACK command, for acknowledging receipt of messages
+      #
+      #  module StompClient
+      #    include EM::P::Stomp
+      #
+      #    def connection_completed
+      #      connect :login => 'guest', :passcode => 'guest'
+      #      # subscribe with ack mode
+      #      subscribe '/some/topic', true
+      #    end
+      #
+      #    def receive_msg msg
+      #      if msg.command == "MESSAGE"
+      #        ack msg.headers['message-id']
+      #        puts msg.body
+      #      end
+      #    end
+      #  end
+      #
+      def ack msgid
+        send_frame "ACK", 'message-id'=> msgid
+      end
+
+    end
+  end
+end
+

data/lib/ext/eventmachine-0.12.10/lib/em/protocols/tcptest.rb

@@ -0,0 +1,53 @@
+#--
+#
+# Author:: Francis Cianfrocca (gmail: blackhedd)
+# Homepage::  http://rubyeventmachine.com
+# Date:: 16 July 2006
+# 
+# See EventMachine and EventMachine::Connection for documentation and
+# usage examples.
+#
+#----------------------------------------------------------------------------
+#
+# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
+# Gmail: blackhedd
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) 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; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#
+#---------------------------------------------------------------------------
+#
+#
+# 
+
+module EventMachine
+  module Protocols
+
+    class TcpConnectTester < Connection # :nodoc:
+      include EventMachine::Deferrable
+
+      def self.test( host, port )
+        EventMachine.connect( host, port, self )
+      end
+
+      def post_init
+        @start_time = Time.now
+      end
+
+      def connection_completed
+        @completed = true
+        set_deferred_status :succeeded, (Time.now - @start_time)
+        close_connection
+      end
+
+      def unbind
+        set_deferred_status :failed, (Time.now - @start_time)  unless @completed
+      end
+    end
+
+  end
+end

data/lib/ext/eventmachine-0.12.10/lib/em/protocols.rb

@@ -0,0 +1,36 @@
+module EventMachine
+  # This module contains various protocol implementations, including:
+  # - HttpClient and HttpClient2
+  # - Stomp
+  # - Memcache
+  # - SmtpClient and SmtpServer
+  # - SASLauth and SASLauthclient
+  # - LineAndTextProtocol and LineText2
+  # - HeaderAndContentProtocol
+  # - Postgres3
+  # - ObjectProtocol
+  #
+  # The protocol implementations live in separate files in the protocols/ subdirectory,
+  # but are auto-loaded when they are first referenced in your application.
+  #
+  # EventMachine::Protocols is also aliased to EM::P for easier usage.
+  #
+  module Protocols
+    # TODO : various autotools are completely useless with the lack of naming
+    # convention, we need to correct that!
+    autoload :TcpConnectTester, 'em/protocols/tcptest'
+    autoload :HttpClient, 'em/protocols/httpclient'
+    autoload :HttpClient2, 'em/protocols/httpclient2'
+    autoload :LineAndTextProtocol, 'em/protocols/line_and_text'
+    autoload :HeaderAndContentProtocol, 'em/protocols/header_and_content'
+    autoload :LineText2, 'em/protocols/linetext2'
+    autoload :Stomp, 'em/protocols/stomp'
+    autoload :SmtpClient, 'em/protocols/smtpclient'
+    autoload :SmtpServer, 'em/protocols/smtpserver'
+    autoload :SASLauth, 'em/protocols/saslauth'
+    autoload :Memcache, 'em/protocols/memcache'
+    autoload :Postgres3, 'em/protocols/postgres3'
+    autoload :ObjectProtocol, 'em/protocols/object_protocol'
+    autoload :Socks4, 'em/protocols/socks4'
+  end
+end

data/lib/ext/eventmachine-0.12.10/lib/em/queue.rb

@@ -0,0 +1,61 @@
+module EventMachine
+  # A cross thread, reactor scheduled, linear queue.
+  #
+  # This class provides a simple "Queue" like abstraction on top of the reactor
+  # scheduler. It services two primary purposes:
+  # * API sugar for stateful protocols
+  # * Pushing processing onto the same thread as the reactor
+  #
+  # See examples/ex_queue.rb for a detailed example.
+  #
+  #  q = EM::Queue.new
+  #  q.push('one', 'two', 'three')
+  #  3.times do
+  #    q.pop{ |msg| puts(msg) }
+  #  end
+  #
+  class Queue
+    # Create a new queue
+    def initialize
+      @items = []
+      @popq  = []
+    end
+
+    # Pop items off the queue, running the block on the reactor thread. The pop
+    # will not happen immediately, but at some point in the future, either in 
+    # the next tick, if the queue has data, or when the queue is populated.
+    def pop(*a, &b)
+      cb = EM::Callback(*a, &b)
+      EM.schedule do
+        if @items.empty?
+          @popq << cb
+        else
+          cb.call @items.shift
+        end
+      end
+      nil # Always returns nil
+    end
+
+    # Push items onto the queue in the reactor thread. The items will not appear
+    # in the queue immediately, but will be scheduled for addition during the 
+    # next reactor tick.
+    def push(*items)
+      EM.schedule do
+        @items.push(*items)
+        @popq.shift.call @items.shift until @items.empty? || @popq.empty?
+      end
+    end
+
+    # N.B. This is a peek, it's not thread safe, and may only tend toward 
+    # accuracy.
+    def empty?
+      @items.empty?
+    end
+
+    # N.B. This is a peek, it's not thread safe, and may only tend toward 
+    # accuracy.
+    def size
+      @items.size
+    end
+  end
+end

data/lib/ext/eventmachine-0.12.10/lib/em/spawnable.rb

@@ -0,0 +1,85 @@
+#--
+#
+# Author:: Francis Cianfrocca (gmail: blackhedd)
+# Homepage::  http://rubyeventmachine.com
+# Date:: 25 Aug 2007
+# 
+# See EventMachine and EventMachine::Connection for documentation and
+# usage examples.
+#
+#----------------------------------------------------------------------------
+#
+# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
+# Gmail: blackhedd
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) 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; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#
+#---------------------------------------------------------------------------
+#
+#
+
+module EventMachine
+  # Support for Erlang-style processes.
+  #
+  class SpawnedProcess
+    # Send a message to the spawned process
+    def notify *x
+      me = self
+      EM.next_tick {
+        # A notification executes in the context of this
+        # SpawnedProcess object. That makes self and notify
+        # work as one would expect.
+        #
+        y = me.call(*x)
+        if y and y.respond_to?(:pull_out_yield_block)
+          a,b = y.pull_out_yield_block
+          set_receiver a
+          self.notify if b
+        end
+      }
+    end
+    alias_method :resume, :notify
+    alias_method :run, :notify # for formulations like (EM.spawn {xxx}).run
+    #attr_accessor :receiver
+
+    #--
+    # I know I'm missing something stupid, but the inside of class << s
+    # can't see locally-bound values. It can see globals, though.
+    def set_receiver blk
+      $em______tmpglobal = blk
+      class << self
+        define_method :call, $em______tmpglobal.dup
+      end
+    end
+
+  end
+
+  class YieldBlockFromSpawnedProcess # :nodoc:
+    def initialize block, notify
+      @block = [block,notify]
+    end
+    def pull_out_yield_block
+      @block
+    end
+  end
+
+  # Spawn an erlang-style process
+  def self.spawn &block
+    s = SpawnedProcess.new
+    s.set_receiver block
+    s
+  end
+
+  def self.yield &block # :nodoc:
+    return YieldBlockFromSpawnedProcess.new( block, false )
+  end
+
+  def self.yield_and_notify &block # :nodoc:
+    return YieldBlockFromSpawnedProcess.new( block, true )
+  end
+end