geary 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 89f649c73ee64b715f88ce8ba647f5e80673edc2
+  data.tar.gz: 2146c0c967c2c1dda7387d850fcf6fc0546db318
+SHA512:
+  metadata.gz: f84185ba53c50612584adf5ddc04e0ffc70b56e21be6f9f1959c184f1dc7bac4bb6955103accabd5ae80c3d6a13120472037262d8e023c00c5e986ec217d9356
+  data.tar.gz: 9e7bc90e9bfad7f8779e6836c6e3a9c2de748bc53ebdc1fc237040f8c9831b2d64624cd4a74dd0ed22d7534a24bc38d40598d8041f5aa9239794156aa472cc5a

data/README.markdown

@@ -0,0 +1,76 @@
+# Geary
+
+Geary gives Gearman job processing a familiar face.
+
+## Getting Started
+
+1. Add Geary to your Gemfile:
+
+  ```ruby
+  gem 'geary', require: false
+  ```
+
+2. Create a worker:
+
+  ```ruby
+    require 'geary/worker'
+
+    class FollowUpWorker
+      extend Geary::Worker
+
+      def perform(id)
+        # User.find(id).tap do |user|
+        #   FollowUpMailer.follow_up_with(user)
+        # end
+      end
+
+    end
+  ```
+
+3. Start working:
+
+  ```
+  geary
+  ```
+
+4. Send jobs to the workers:
+
+  ```ruby
+  FollowUpWorker.perform_async(1)
+  ```
+
+## Configuring Geary
+
+Without configuration, Geary will spawn 25 workers, each of which will process jobs from a Gearman server running on `localhost:4730`. Geary can be configured to process jobs from a different Gearman server, as well as from multiple servers. For instance, if you're running a Gearman server on a different address, you might start the workers like this:
+
+```
+geary -s gearman://localhost:4731
+```
+
+Processing jobs from multiple servers is a matter of passing in comma-delimited addresses:
+
+```
+geary -s gearman://localhost:4730,gearman://localhost:4731
+```
+
+Classes which extend themselves with `Geary::Worker` submit background jobs to a Gearman server running on `localhost:4730` by default, but can be configured to submit jobs to multiple servers like so:
+
+```ruby
+require 'geary/worker'
+
+class OverheadWorker
+  extend Geary::Worker
+
+  use_gearman_client 'gearman://localhost:4730', 'gearman://localhost:4731'
+
+  def perform ; end
+end
+```
+
+The following code will submit four jobs.
+
+```ruby
+4.times { OverheadWorker.perform_async }
+```
+
+If the server listening on port 4730 disappears midway, our gearman client will disconnect from it, and submit future jobs to the server listening on 4731. As of right now, there is no backoff behavior. If the server listening on 4731 disappears and we're still not out of jobs to submit, we'll attempt to reconnect to `localhost:4730`, potentially to our never-ending dismay.

data/bin/geary

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+$:.unshift(
+  File.expand_path(File.join(File.expand_path(__FILE__), '..', '..', 'lib'))
+)
+
+require 'geary/cli'
+
+Geary::CLI.new(ARGV.dup).execute!

data/lib/gearman/client.rb

@@ -0,0 +1,80 @@
+require 'celluloid'
+require 'gearman/connection'
+require 'gearman/packet'
+require 'securerandom'
+require 'uri'
+
+module Gearman
+  class Client
+    include Celluloid
+
+    trap_exit :reconnect
+    finalizer :disconnect
+
+    def initialize(*addresses)
+      @addresses = addresses.map(&Kernel.method(:URI))
+      @generate_unique_id = SecureRandom.method(:uuid)
+      @addresses_by_connection_id = {}
+      @connections = []
+      build_connections
+    end
+
+    def submit_job_bg(function_name, data)
+      packet = Packet::SUBMIT_JOB_BG.new(
+        function_name: function_name,
+        unique_id: @generate_unique_id.(),
+        data: data
+      )
+
+      with_connection do |connection|
+        connection.write(packet)
+        connection.async.next
+      end
+    end
+
+    def generate_unique_id_with(methodology)
+      @generate_unique_id = methodology
+    end
+
+    def disconnect
+      @connections.select(&:alive?).each(&:terminate)
+    end
+
+    def build_connections
+      @addresses.each do |address|
+        build_connection(address)
+      end
+    end
+
+    def build_connection(address)
+      connection = Connection.new_link(address)
+      @addresses_by_connection_id[connection.object_id] = address
+      @connections << connection
+    end
+
+    def reconnect(connection = nil, reason = nil)
+      Celluloid.logger.debug(reason) if reason
+
+      connection ||= current_connection
+      connection.terminate if connection.alive?
+
+      forget_connection(connection) do |address|
+        build_connection(address)
+      end
+    end
+
+    def with_connection(&action)
+      action.call(current_connection)
+    end
+
+    def current_connection
+      @connections.first
+    end
+
+    def forget_connection(connection)
+      @connections.delete(connection)
+      yield @addresses_by_connection_id[connection.object_id]
+    end
+
+  end
+end

data/lib/gearman/connection.rb

@@ -0,0 +1,132 @@
+require 'celluloid/io'
+require 'gearman/packet'
+require 'gearman/error'
+
+module Gearman
+  class Connection
+    include Celluloid::IO
+
+    finalizer :disconnect
+
+    unless defined? IncompleteReadError
+      IncompleteReadError = Class.new(Gearman::Error)
+      IncompleteWriteError = Class.new(Gearman::Error)
+      NoConnectionError = Class.new(Gearman::Error)
+      UnexpectedPacketError = Class.new(Gearman::Error)
+      ServerError = Class.new(Gearman::Error)
+
+      NULL_BYTE = "\0"
+      REQ = [NULL_BYTE, "REQ"].join
+      HEADER_FORMAT = "a4NN"
+      HEADER_SIZE = 12
+    end
+
+    def initialize(address)
+      @address = address
+      @repository = Packet::Repository.new
+      @socket = nil
+    end
+
+    def write(packet)
+      connect if disconnected?
+
+      body = packet.arguments.join(NULL_BYTE)
+      header = [REQ, packet.number, body.size].pack(HEADER_FORMAT)
+
+      serialized_packet = header + body
+
+      length_written = @socket.write(serialized_packet)
+
+      debug "Wrote #{packet.inspect}"
+
+      if length_written != serialized_packet.length
+        lengths = [serialized_packet.length, lengths]
+        message = "expected to write %d bytes, but only read %d" % lengths
+
+        raise IncompleteWriteError, message
+      end
+    end
+
+    def next(*expected_packet_types)
+      connect if disconnected?
+
+      header = read(HEADER_SIZE)
+      magic, type, length = header.unpack(HEADER_FORMAT)
+
+      body = read(length)
+      arguments = String(body).split(NULL_BYTE)
+
+      @repository.load(type).new(arguments).tap do |packet|
+        debug "Read #{packet.inspect}"
+
+        if packet.is_a?(Packet::ERROR)
+          message = "server sent error #{packet.error_code}: #{packet.text}"
+
+          raise ServerError, message
+        end
+
+        verify packet, expected_packet_types
+      end
+    end
+
+    def disconnect
+      if @socket
+        @socket.close unless @socket.closed?
+        @socket = nil
+      end
+    end
+
+    private
+
+    def read(length)
+      return unless length > 0
+
+      data = @socket.read(length)
+
+      if data.nil?
+        raise NoConnectionError, "lost connection to #{@address}"
+      elsif data.length != length
+        lengths = [length, data.length]
+        message = "expected to read %d bytes, but only read %d" % lengths
+
+        raise IncompleteReadError, message
+      else
+        data
+      end
+    end
+
+    def connect
+      begin
+        @socket = TCPSocket.new(@address.host, @address.port)
+
+        info "Connected"
+      rescue => error
+        raise NoConnectionError.new("could not connect to #{@address}", error)
+      end
+    end
+
+    def disconnected?
+      @socket.nil?
+    end
+
+    def verify(packet, valid_packet_types)
+      return if valid_packet_types.empty?
+
+      unless valid_packet_types.include?(packet.class)
+        valid_type = valid_packet_types.join(' or ')
+        message = "expected #{packet} to be a #{valid_type}"
+
+        raise UnexpectedPacketError, message
+      end
+    end
+
+    def debug(note)
+      Celluloid.logger.debug "#{@address}: #{note}"
+    end
+
+    def info(note)
+      Celluloid.logger.info "#{@address}: #{note}"
+    end
+
+  end
+end

data/lib/gearman/error.rb

@@ -0,0 +1,7 @@
+require 'nestegg'
+
+module Gearman
+  class Error < StandardError
+    include Nestegg::NestingException
+  end
+end

data/lib/gearman/packet.rb

@@ -0,0 +1,9 @@
+require 'gearman/packet/repository'
+
+module Gearman
+  module Packet
+    self.tap do
+      Repository.new
+    end
+  end
+end

data/lib/gearman/packet/repository.rb

@@ -0,0 +1,35 @@
+require 'gearman/packet/sugar'
+
+module Gearman
+  module Packet
+    class Repository
+
+      def initialize
+        @by_number = {}
+        store(1, 'CAN_DO', [:function_name])
+        store(2, 'CANT_DO', [:function_name])
+        store(4, 'PRE_SLEEP')
+        store(6, 'NOOP')
+        store(8, 'JOB_CREATED', [:handle])
+        store(9, 'GRAB_JOB')
+        store(10, 'NO_JOB')
+        store(11, 'JOB_ASSIGN', [:handle, :function_name, :data])
+        store(13, 'WORK_COMPLETE', [:handle, :data])
+        store(18, 'SUBMIT_JOB_BG', [:function_name, :unique_id, :data])
+        store(19, 'ERROR', [:error_code, :text])
+        store(25, 'WORK_EXCEPTION', [:handle, :data])
+      end
+
+      def store(number, type, takes = [])
+        Sugar.type(type, number: number, takes: takes).tap do |packet_type|
+          @by_number[number] = packet_type
+        end
+      end
+
+      def load(number)
+        @by_number[number]
+      end
+
+    end
+  end
+end

data/lib/gearman/packet/sugar.rb

@@ -0,0 +1,103 @@
+module Gearman
+  module Packet
+    module Sugar
+
+      def self.type(name, options)
+        if Gearman::Packet.const_defined?(name)
+          return Gearman::Packet.const_get(name)
+        end
+
+        class_ = Class.new do
+          extend Sugar
+
+          takes *Array(options[:takes])
+          number Integer(options[:number])
+
+          def inspect
+            info = argument_names.map do |argument_name|
+              "#{argument_name}=#{public_send(argument_name)}"
+            end
+
+            if info.any?
+              "#<#{self.class.name} #{info.join(' ')}>"
+            else
+              "#<#{self.class.name}>"
+            end
+          end
+
+          def ==(other)
+            quack = other.respond_to?(:arguments) && other.respond_to?(:number)
+
+            if quack
+              arguments == other.arguments && number == other.number
+            else
+              false
+            end
+          end
+          alias :eql? :==
+
+        end
+
+        Gearman::Packet.const_set(name, class_)
+      end
+
+      def takes(*arguments)
+        define_method(:initialize) do |attributes_or_arguments = []|
+          __sugar_set = ->(argument, value) do
+            ivar = "@#{argument}"
+
+            instance_variable_set(ivar, value)
+          end
+
+          if attributes_or_arguments.is_a?(Hash)
+            attributes = attributes_or_arguments
+            arguments.each do |argument|
+              begin
+                value = attributes.fetch(argument.to_sym)
+              rescue KeyError
+                raise ArgumentError, "expected to be given :#{argument}"
+              end
+
+              __sugar_set.(argument, value)
+            end
+          elsif attributes_or_arguments.is_a?(Array)
+            given = attributes_or_arguments
+
+            if given.size != arguments.size
+              raise ArgumentError,
+                "expected to be given #{arguments.size} arguments"
+            end
+
+            arguments.zip(given).each do |argument, value|
+              __sugar_set.(argument, value)
+            end
+          else
+            raise ArgumentError,
+              "expected either a Hash of attributes or an Array of arguments"
+          end
+        end
+
+        attr_reader(*arguments)
+
+        define_method(:argument_names) do
+          self.class.const_get('ARGUMENTS')
+        end
+
+        define_method(:arguments) do
+          argument_names.map { |argument_name| public_send(argument_name) }
+        end
+
+        self.const_set('ARGUMENTS', arguments)
+      end
+
+      def number(n)
+        define_method(:number) do
+          self.class.const_get('NUMBER')
+        end
+
+        self.const_set('NUMBER', n)
+      end
+
+    end
+  end
+end