maxwell_agent 0.0.5 → 0.0.7

data/lib/maxwell/agent/evented_worker.rb

@@ -0,0 +1,7 @@
+module Maxwell
+  module Agent
+    class EventedWorker < Worker
+      include Celluloid::IO
+    end
+  end
+end

data/lib/maxwell/agent/host.rb

@@ -1,27 +1,48 @@
 module Maxwell
   module Agent
     class Host
-      include DynamicAttributes
+      attr_reader :attributes
+      require 'maxwell/agent/host/service'
 
-      class Service
-        include Work
-        def initialize(attrs={})
-          @hosts ||= []
+      class Serializer
+        include Coercable
+
+        coerce :services, ->(services) {
+          services.map { |service|
+            Service::Serializer.deserialize(service)
+          }}
+        def self.serialize(attrs)
+          attrs.services = attrs.services.map(&:serialize)
+          JSON.dump attrs
+        end
+
+        def self.deserialize(json)
+          hash = JSON.parse(json, symbolize_names: true)
+          Host.new(new.coerce_values!(hash))
         end
       end
 
+
       def initialize(attrs={})
-        @services ||= []
-        @hosts ||= []
+        @attributes = Attributes.new(attrs)
+        @attributes.services ||= []
+      end
+
+      def serialize
+        Serializer.serialize(attributes.dup)
       end
 
+
       def add_service(service)
-        self.services << service
+        @attributes[:services] << service
       end
 
-      def add_host(host)
-        self.hosts << host
+      def services
+        @attributes[:services]
       end
+
     end
+
   end
 end
+

data/lib/maxwell/agent/host/service.rb

@@ -0,0 +1,49 @@
+module Maxwell
+  module Agent
+    class Host
+      class Service
+        extend Forwardable
+        attr_reader :attributes
+        include Work
+
+        def_delegators :attributes,
+          :perform_at, :perform_at=,
+          :last_run, :last_run=,
+          :frequency, :frequency=,
+          :work_class, :work_class=
+
+        class Serializer
+          include Coercable
+
+          coerce :perform_at, Time
+          coerce :last_run, Time
+
+          def self.serialize(attrs)
+            attrs.last_run   = attrs.last_run.to_s if attrs.last_run
+            attrs.perform_at = attrs.perform_at.to_s if attrs.perform_at
+            JSON.dump attrs
+          end
+
+          def self.deserialize(json)
+            hash = JSON.parse(json, symbolize_names: true)
+            Service.new(new.coerce_values!(hash))
+          end
+        end
+
+        def initialize(attrs={})
+          @attributes = Attributes.new(attrs)
+          set_default_attrs!
+        end
+
+        def serialize
+          Serializer.serialize(attributes.dup)
+        end
+
+        def to_json
+          serialize
+        end
+
+      end
+    end
+  end
+end

data/lib/maxwell/agent/middleware_runner.rb

@@ -0,0 +1,11 @@
+module Maxwell
+  module Agent
+    class MiddlewareRunner
+      include Celluloid
+
+      def invoke(work)
+        Agent.middleware.invoke(work)
+      end
+    end
+  end
+end

data/lib/maxwell/agent/probe.rb

@@ -9,6 +9,10 @@ module Maxwell
         end
       end
 
+      def work_type
+        self.class.work_type
+      end
+
       module ClassMethods
         def perform(*args)
           probe = instance(*args)
@@ -25,6 +29,14 @@ module Maxwell
         def call_handler(probe)
           probe.handle if probe.respond_to?(:handle)
         end
+
+        def work_type
+          @work_type ||= :non_evented
+        end
+
+        def work_type=(value)
+          @work_type = value.to_sym
+        end
       end
     end
   end

data/lib/maxwell/agent/redis_objects.rb

@@ -0,0 +1,18 @@
+module Maxwell
+  module Agent
+    module RedisObjects
+      def redis(&block)
+        Agent.redis(&block)
+      end
+
+      def self.included(base)
+        base.send(:include, ::Celluloid)
+      end
+    end
+  end
+end
+
+require 'maxwell/agent/redis_objects/set'
+require 'maxwell/agent/redis_objects/sorted_set'
+
+

data/lib/maxwell/agent/redis_objects/set.rb

@@ -0,0 +1,42 @@
+module Maxwell
+  module Agent
+    module RedisObjects
+      class Set
+        include RedisObjects
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+        end
+
+        def add(object)
+          redis {|redis| redis.sadd name, object.to_json }
+        end
+
+        def remove(object)
+          redis {|redis| redis.srem name, object.to_json }
+        end
+
+        def all
+          redis {|redis| redis.smembers name}
+        end
+
+        def count
+          redis {|redis| redis.scard name }
+        end
+
+        def exists?(object)
+          if redis {|redis| redis.sismember name, object.to_json }
+            true
+          else
+            false
+          end
+        end
+
+        def find_by(key, value)
+          all.reject {|host| host if host.key != value }
+        end
+      end
+    end
+  end
+end

data/lib/maxwell/agent/redis_objects/sorted_set.rb

@@ -0,0 +1,35 @@
+module Maxwell
+  module Agent
+    module RedisObjects
+      class SortedSet
+        include RedisObjects
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+        end
+
+        def add(score, object)
+          redis { |redis| redis.zadd name, score, object.to_json }
+        end
+
+        def count
+          redis {|redis| redis.zcard name }
+        end
+
+        def all
+          redis {|redis| redis.zrange name, 0, -1 }
+        end
+
+        def first
+          redis { |redis| redis.zrange(name, 0, 0)[0] }
+        end
+
+        def remove(item)
+          redis { |redis| redis.zrem name, item.to_json }
+        end
+
+      end
+    end
+  end
+end

data/lib/maxwell/agent/runner.rb

@@ -1,6 +1,9 @@
 require 'maxwell/agent/worker'
+require 'maxwell/agent/standard_worker'
+require 'maxwell/agent/evented_worker'
 require 'maxwell/agent/scheduler'
 require 'maxwell/agent/work_schedule'
+require 'maxwell/agent/middleware_runner'
 
 module Maxwell
   module Agent
@@ -12,25 +15,25 @@ module Maxwell
         Agent.configuration.worker_concurrency
       end
 
-      supervise Agent::WorkSchedule, as: :work_schedule
-      pool Agent::Worker, as: :worker, size: worker_pool_size
-      supervise Agent::Scheduler, as: :scheduler
-
-      def [](actor_name)
-        @registry[actor_name]
-      end
-
       def initialize(opts)
         super
-        wait_for_actor_boot
+
+        pool Agent::MiddlewareRunner, size: self.class.worker_pool_size
+        supervise_as :work_schedule, Agent::WorkSchedule
+        pool Agent::StandardWorker, as: :worker, size: self.class.worker_pool_size
+        supervise_as :evented_worker, Agent::EventedWorker
+        supervise_as :scheduler, Agent::Scheduler,
+          work_schedule: self[:work_schedule],
+          worker: self[:worker],
+          evented_worker: self[:evented_worker]
+
+
+        self[:scheduler].async.run
+
       end
 
-      def wait_for_actor_boot
-        loop do
-          break if self[:work_schedule] &&
-            self[:worker] &&
-            self[:scheduler]
-        end
+      def [](actor_name)
+        @registry[actor_name]
       end
     end
   end

data/lib/maxwell/agent/scheduler.rb

@@ -3,15 +3,16 @@ module Maxwell
     class Scheduler
       include Celluloid
 
-      def initialize
-        async.run
-      end
+      attr_reader :work_schedule, :evented_worker, :worder
 
-      def work_schedule
-        runner[:work_schedule]
+      def initialize(opts={})
+        @work_schedule ||= opts.fetch(:work_schedule)
+        @evented_worker ||= opts.fetch(:evented_worker)
+        @worker ||= opts.fetch(:worker)
       end
 
       def run
+        set_links
         loop do
           sleep Agent.configuration.work_poll
           schedule_work
@@ -19,16 +20,19 @@ module Maxwell
       end
 
       def schedule_work
-        work = work_schedule.get
-        worker.async.perform(work) if work
-      end
-
-      def worker
-        runner[:worker]
+        if work = work_schedule.get
+          if work.evented?
+            evented_worker.async.perform(work)
+          else
+            worker.async.perform(work)
+          end
+        end
       end
-
-      def runner
-        links.detect {|link| Celluloid::SupervisionGroup === link }
+    private
+      def set_links
+        link(@evented_worker)
+        link(@worker)
+        link(@work_schedule)
       end
 
     end

data/lib/maxwell/agent/standard_worker.rb

@@ -0,0 +1,7 @@
+module Maxwell
+  module Agent
+    class StandardWorker < Worker
+      include Celluloid
+    end
+  end
+end

data/lib/maxwell/agent/version.rb

@@ -1,5 +1,5 @@
 module Maxwell
   module Agent
-    VERSION = "0.0.5"
+    VERSION = "0.0.7"
   end
 end

data/lib/maxwell/agent/work.rb

@@ -3,52 +3,10 @@ module Maxwell
     module Work
       class MissingRequiredAttributeError < StandardError; end
 
-      REQUIRED_ATTRIBUTES = [:name, :work_class]
-      #WORK_ATTRIBUTES     = [:last_run, :frequency, :perform_at].
-      #  concat(REQUIRED_ATTRIBUTES)
-
-      def self.included(base)
-        base.send(:include, DynamicAttributes)
-      end
-
-
       def self.load(json)
-        work = from_json(json)
-        work.delete('klass').constantize.new.load(work)
+        Agent::Host::Service::Serializer.deserialize(json)
       end
 
-      def self.from_json(json)
-        JSON.parse(json)
-      end
-
-      def load(attrs={})
-        attrs.each do |key, value|
-          send("#{key}=", value )
-        end
-        self
-      end
-
-      def to_json
-        verify_required_attributes!
-        instance_variables.inject({}) do |result, attr|
-          result.merge(attr.to_s.gsub('@','') => instance_variable_get(attr))
-        end.merge({klass: self.class}).to_json
-      end
-
-      def verify_required_attributes!
-        REQUIRED_ATTRIBUTES.each do |required_attr|
-          raise MissingRequiredAttributeError,
-            "Must set #{required_attr}" unless send(required_attr)
-        end
-      end
-
-      def last_run
-        super || self.last_run = Time.new(0)
-      end
-
-      def frequency
-        super || self.frequency = 30.minutes
-      end
 
       def work_now?
         case
@@ -62,7 +20,7 @@ module Maxwell
         case
           when perform_at               then perform_at + last_run.to_i
           when (last_run && frequency)  then last_run + frequency
-          else                          Time.new
+          else                          Time.new(0)
         end
       end
 
@@ -74,7 +32,22 @@ module Maxwell
         work_class.perform(*arguments)
       end
 
+      def evented?
+        work_class.work_type == :evented
+      end
+
+      def verify_required_attributes!
+        case
+          when work_class.nil? then raise MissingRequiredAttributeError
+        end
+      end
+
     private
+      def set_default_attrs!
+        self.last_run ||= Time.new(0)
+        self.frequency ||= 30.minutes
+      end
+
       def time_since_last_run
         Time.now.to_i - last_run.to_i
       end
@@ -87,6 +60,8 @@ module Maxwell
       def stale?
         time_since_last_run >= frequency
       end
+
+
     end
   end
 end