sidekick-client 0.2.1 → 0.2.2

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

@@ -1,200 +0,0 @@
-#--
-#
-# 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

@@ -1,53 +0,0 @@
-#--
-#
-# 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

@@ -1,36 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,85 +0,0 @@
-#--
-#
-# 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

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

@@ -1,130 +0,0 @@
-#--
-#
-# Author:: Francis Cianfrocca (gmail: blackhedd)
-# Homepage::  http://rubyeventmachine.com
-# Date:: 16 Jul 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
-  class FileStreamer
-    include Deferrable
-
-    # Use mapped streamer for files bigger than 16k
-    MappingThreshold = 16384
-    # Wait until next tick to send more data when 50k is still in the outgoing buffer
-    BackpressureLevel = 50000
-    # Send 16k chunks at a time
-    ChunkSize = 16384
-
-    # Stream a file over a given connection. An optional :http_chunks => true argument will
-    # use HTTP 1.1 style chunked-encoding semantics.
-    #
-    #  module FileSender
-    #    def post_init
-    #      streamer = EventMachine::FileStreamer.new(self, '/tmp/bigfile.tar')
-    #      streamer.callback{
-    #        # file was sent successfully
-    #        close_connection_after_writing
-    #      }
-    #    end
-    #  end
-    #
-    def initialize connection, filename, args = {}
-      @connection = connection
-      @http_chunks = args[:http_chunks]
-
-      if File.exist?(filename)
-        @size = File.size?(filename)
-        if @size <= MappingThreshold
-          stream_without_mapping filename
-        else
-          stream_with_mapping filename
-        end
-      else
-        fail "file not found"
-      end
-    end
-
-    def stream_without_mapping filename # :nodoc:
-      if @http_chunks
-        @connection.send_data "#{@size.to_s(16)}\r\n"
-        @connection.send_file_data filename
-        @connection.send_data "\r\n0\r\n\r\n"
-      else
-        @connection.send_file_data filename
-      end
-      succeed
-    end
-    private :stream_without_mapping
-
-    def stream_with_mapping filename # :nodoc:
-      ensure_mapping_extension_is_present
-
-      @position = 0
-      @mapping = EventMachine::FastFileReader::Mapper.new filename
-      stream_one_chunk
-    end
-    private :stream_with_mapping
-
-    # Used internally to stream one chunk at a time over multiple reactor ticks
-    def stream_one_chunk
-      loop {
-        if @position < @size
-          if @connection.get_outbound_data_size > BackpressureLevel
-            EventMachine::next_tick {stream_one_chunk}
-            break
-          else
-            len = @size - @position
-            len = ChunkSize if (len > ChunkSize)
-
-            @connection.send_data( "#{len.to_s(16)}\r\n" ) if @http_chunks
-            @connection.send_data( @mapping.get_chunk( @position, len ))
-            @connection.send_data("\r\n") if @http_chunks
-
-            @position += len
-          end
-        else
-          @connection.send_data "0\r\n\r\n" if @http_chunks
-          @mapping.close
-          succeed
-          break
-        end
-      }
-    end
-
-    #--
-    # We use an outboard extension class to get memory-mapped files.
-    # It's outboard to avoid polluting the core distro, but that means
-    # there's a "hidden" dependency on it. The first time we get here in
-    # any run, try to load up the dependency extension. User code will see
-    # a LoadError if it's not available, but code that doesn't require
-    # mapped files will work fine without it. This is a somewhat difficult
-    # compromise between usability and proper modularization.
-    #
-    def ensure_mapping_extension_is_present # :nodoc:
-      @@fastfilereader ||= (require 'fastfilereaderext')
-    end
-    private :ensure_mapping_extension_is_present
-
-  end
-end
-

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

@@ -1,56 +0,0 @@
-module EventMachine
-  # Creates a one-time timer
-  #
-  #  timer = EventMachine::Timer.new(5) do
-  #    # this will never fire because we cancel it
-  #  end
-  #  timer.cancel
-  #
-  class Timer
-    # Create a new timer that fires after a given number of seconds
-    def initialize interval, callback=nil, &block
-      @signature = EventMachine::add_timer(interval, callback || block)
-    end
-
-    # Cancel the timer
-    def cancel
-      EventMachine.send :cancel_timer, @signature
-    end
-  end
-
-  # Creates a periodic timer
-  #
-  #  n = 0
-  #  timer = EventMachine::PeriodicTimer.new(5) do
-  #    puts "the time is #{Time.now}"
-  #    timer.cancel if (n+=1) > 5
-  #  end
-  #
-  class PeriodicTimer
-    # Create a new periodic timer that executes every interval seconds
-    def initialize interval, callback=nil, &block
-      @interval = interval
-      @code = callback || block
-      @cancelled = false
-      schedule
-    end
-
-    # Cancel the periodic timer
-    def cancel
-      @cancelled = true
-    end
-
-    # Fire the timer every interval seconds
-    attr_accessor :interval
-
-    def schedule # :nodoc:
-      EventMachine::add_timer @interval, method(:fire)
-    end
-    def fire # :nodoc:
-      unless @cancelled
-        @code.call
-        schedule
-      end
-    end
-  end
-end

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

@@ -1,3 +0,0 @@
-module EventMachine
-  VERSION = "0.12.10"
-end