factor 0.1.09 → 0.1.10

data/lib/channel/listener.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+
+module Factor  
+  module Channel
+    class Listener
+      attr_accessor :workflow_id, :event
+
+      def start(params,&code)
+      end
+
+      def stop()
+      end
+
+      def initialize(workflow_id,event)
+        @workflow_id=workflow_id
+        @event=event
+      end
+    end
+  end
+end

data/lib/cli/workflow_task.rb

@@ -11,11 +11,26 @@ module Factor
         puts "starting workflow #{workflow_name} with options #{options.parameters.to_s}"
     
         engine = Factor::Runtime::Engine.new(get_config[:email],get_config[:token])
-        id = engine.launch(workflow_name,options.parameters)
+        id = engine.send_start_workflow(workflow_name,options.parameters)
     
         puts "workflow executed with id #{id}"
       end
   
+      desc "listen WORKFLOW","start listener for workflow"
+      def listen(workflow_name)
+        puts "starting listener #{workflow_name}"
+    
+        engine = Factor::Runtime::Engine.new(get_config[:email],get_config[:token])
+        engine.send_start_listener(workflow_name)
+      end
+
+      desc "stop WORKFLOW","stop listener for workflow"
+      def stop(workflow_name)
+        puts "starting listener #{workflow_name}"
+    
+        engine = Factor::Runtime::Engine.new(get_config[:email],get_config[:token])
+        engine.send_stop_listener(workflow_name)
+      end
       
       
       desc "list", "list all the workflows"

data/lib/runtime/engine.rb

@@ -7,16 +7,17 @@ require 'mustache'
 module Factor
   module Runtime
     class Engine
-      attr_accessor :channel_modules, :workflows, :message_bus
+      attr_accessor :channel_modules, :workflows, :message_bus, :listeners
     
       # Engine needs modules that contain the code, workflows to run, and message bus for communication
       def initialize(username,token)
-        @channel_modules=Hash.new
-        @channel_definitions=Array.new
-        @workflows = Hash.new
+        @channel_modules={}
+        @channel_definitions=[]
+        @workflows = {}
         @message_bus = MessageBus.new(username,token)
-        @credentials = Hash.new
-        @tags = Hash.new
+        @credentials = {}
+        @tags = {}
+        @listeners={}
       end
     
       def tag(key,value)
@@ -38,7 +39,14 @@ module Factor
       end
     
       def load_credentials credentials,secret=nil
-        @credentials["credentials"] = credentials
+        credentials.each do |service_name,services|
+          @credentials[service_name] = {} if !@credentials.include?(service_name)
+          services.each do |credential_name,credential|
+            @credentials[service_name][credential_name] = credential["value"]
+          end
+        end
+        
+        # @credentials["credentials"] = credentials
       end
     
       # adds the workflow to the workflows list
@@ -55,11 +63,11 @@ module Factor
         end
       end
     
-      def launch workflow, params, keep_open=false
+      def send_start_workflow workflow, params, keep_open=false
         instance_id=SecureRandom.hex
         
         @message_bus.start do
-          message = Message.new
+          message = WorkflowStepMessage.new
           message.position << "start"
           message.workflow=workflow
           message.add_values params
@@ -68,51 +76,116 @@ module Factor
         end
         instance_id
       end
+
+      def send_start_listener workflow_name, keep_open=false
+        @message_bus.start do
+          message = ListenerMessage.new("start",workflow_name)
+          @message_bus.send message, !keep_open
+        end
+      end
+
+      def send_stop_listener workflow_name, keep_open=false
+        @message_bus.start do
+          message = ListenerMessage.new("stop",workflow_name)
+          @message_bus.send message, !keep_open
+        end
+      end
     
       # start your engines. vroom vrooooom!
       def start
         begin
           @message_bus.start do
-            @message_bus.listen do |message|
-              if @workflows.include? message.workflow
-                workflow = @workflows[message.workflow]
-                activity = workflow.get_activity(message.position)
+            @message_bus.listen("listener") do |payload|
+              message = ListenerMessage.new
+              message.from_queue(payload)
+
+              listener=@workflows[message.workflow].definition["listener"]
+              params = render_template(listener["params"],@credentials)
+
+              if message.command=="start"
+                start_listening(listener["channel"],listener["name"],listener["event"],message.workflow,params)
+              else
+                stop_listening(listener["channel"],listener["name"],listener["event"],message.workflow)
+              end
+            end
+
+            @message_bus.listen("workflow") do |payload|
+              step = WorkflowStepMessage.new
+              step.from_queue(payload)
+              if @workflows.include? step.workflow
+                workflow = @workflows[step.workflow]
+                activity = workflow.get_activity(step.position)
                 if !activity.nil?
                   action = activity["action"]
                   channel = activity["channel"]
                   target = activity["target"]
                   params_template = activity["params"]
-              
-                  # if match(target)              
-                    values = message.body.merge(@credentials)
+                  
+                  # if match(target)
+                  values = step.body.merge(@credentials)
+                  # puts "Values: #{values.inspect}"
 
-                    # this maps the input values passed in with the templated defined in the workflow
-                    params = render_template(params_template,values)
-                    event = call_channel_method(channel,action,params)
-                    response_message = message.respond(event.params,event.class.name.split("::").last)
+                  # this maps the input values passed in with the templated defined in the workflow
+                  params = render_template(params_template,values)
+                  puts "content: #{params}"
+                  event = call_channel_method(channel,action,params)
+                  response_message = step.respond(event.params,event.class.name.split("::").last)
               
-                    @message_bus.send response_message
+                  @message_bus.send response_message
                   # end
+                else
+                  puts "[error] no activity found for position '#{step.position}'"
                 end
               else
                 # workflow doesn't exist
+                puts "[warning] '#{step.workflow}' workflow wasn't found"
               end
             end
           end
         rescue SystemExit, Interrupt
-          "done"
+          puts "done"
         rescue Exception => ex
-          ex
+          puts ex
         end
       end
 
       def call_channel_method(channel_name,action_name,params)
         channel_module_name = get_channel_module(channel_name)
         channel_module = @channel_modules[channel_module_name]
-        action_class = get_action_class(channel_name,action_name)
-        command = channel_module.const_get(action_class)
+        action_class_name = get_class_name("actions",channel_name,action_name)
+        command = channel_module.const_get(action_class_name)
         command.new.do_work(params)
       end
+
+      def start_listening(channel_name,listener_name,event,workflow_name,params)
+        channel_module_name = get_channel_module(channel_name)
+        channel_module = @channel_modules[channel_module_name]
+        listener_class_name = get_class_name("listeners",channel_name,listener_name)
+        command = channel_module.const_get(listener_class_name)
+        job_info = {:channel_name=>channel_name,:listener_name=>listener_name,:workflow_name=>workflow_name,:event=>event}.to_json
+
+        @job = Thread.new do
+          puts "Creating listener #{channel_name}::#{listener_name} on event '#{event}' => #{workflow_name}"
+          listener=command.new(workflow_name,event)
+
+          puts "Starting listener thread #{params}"
+          listener.start params do |event_params|
+            send_start_workflow workflow_name, event_params
+          end
+        end
+        @listeners[job_info]=@job
+      end
+
+      def stop_listening(channel_name,listener_name,event,workflow_name)
+        # channel_module_name = get_channel_module(channel_name)
+        # channel_module = @channel_modules[channel_module_name]
+        # listener_class = get_class_name("listeners",channel_name,listener_name)
+        # command = channel_module.const_get(listener_name)
+        job_info = {:channel_name=>channel_name,:listener_name=>listener_name,:workflow_name=>workflow_name,:event=>event}.to_json
+
+        @listeners[job_info].kill if @listeners.include?(job_info)
+
+      end
       
       private 
       
@@ -120,11 +193,31 @@ module Factor
         @channel_definitions.select { |channel_definition| channel_definition['name']==channel_name }.first['module_name']
       end
 
-      def get_action_class(channel_name,action_name)
+      # def get_action_class(channel_name,action_name)
+      #   @channel_definitions.each do |channel_definition|
+      #     if channel_definition['name']==channel_name
+      #       channel_definition['actions'].each do |action|
+      #         return action["class_name"] if action['name']==action_name
+      #       end
+      #     end
+      #   end
+      # end
+
+      # def get_listener_class(channel_name,listener_name)
+      #   @channel_definitions.each do |channel_definition|
+      #     if channel_definition['name']==channel_name
+      #       channel_definition['listeners'].each do |listener|
+      #         return listener["class_name"] if listener['name']==listener_name
+      #       end
+      #     end
+      #   end
+      # end
+
+      def get_class_name(type,channel_name,class_name)
         @channel_definitions.each do |channel_definition|
           if channel_definition['name']==channel_name
-            channel_definition['actions'].each do |action|
-              return action["class_name"] if action['name']==action_name
+            channel_definition[type].each do |definition|
+              return definition["class_name"] if definition['name']==class_name
             end
           end
         end

data/lib/runtime/listener_message.rb

@@ -0,0 +1,42 @@
+require 'rubygems'
+require 'json/ext'
+
+module Factor
+  module Runtime
+    class ListenerMessage
+      attr_accessor :command,:workflow
+      def initialize(command=nil,workflow=nil)
+        @command=command
+        @workflow=workflow
+      end
+
+
+      def route
+        # "#{workflow}.#{position.join('.')}"
+        "listener"
+      end
+    
+      def payload
+        JSON.generator = JSON::Ext::Generator
+        obj = {"command"=>@command, "workflow"=>@workflow}
+        JSON.generate(obj)
+      end
+    
+      def from_queue payload
+        message=JSON.parse(payload)
+        @command=message["command"]
+        @workflow=message["workflow"]
+      end
+      # def from_queue payload
+      #   
+      #   @workflow = message["workflow"]
+      #   @position=message["position"]
+      #   @body=message["body"]
+      #   @workflow_instance_id=message["workflow_instance_id"]
+      #   @step_id=message["step_id"]
+      #   @last_step_id=message["last_step_id"]
+      # end
+    
+    end
+  end
+end

data/lib/runtime/message_bus.rb

@@ -18,7 +18,7 @@ module Factor
       # Creates the connection and creates a topic exchange
       # An exchange references a place to send messages to
       # the exchange routes it to the queues based on the route_key
-      def start(topic="workflow",&code)
+      def start(topic="factor",&code)
         EventMachine.run do
           #connection_settings={:host=>@host,:user=>@username,:password=>@token,:vhost=>@vhost}
           connection_settings={:host=>@host}
@@ -36,15 +36,14 @@ module Factor
         @queue.bind(@exchange, :routing_key=>routing_key) # bind queue to the Exchange
       
         @queue.subscribe do |headers,payload|
-          message = Message.new
-          message.from_queue headers.routing_key, payload
-          puts "[Received Message (#{message.route})] #{message.body.inspect}"
-          code.call(message)
+          # code.call(headers.routing_key,payload)
+          puts "[Received Message (#{headers.routing_key})] #{payload.inspect}"
+          code.call(payload)
         end
       end
     
       def send(message,close=false)
-        puts "[Sending Message (#{message.route})] #{message.body.inspect}"
+        puts "[Sending Message (#{message.route})] #{message.payload.inspect}"
         @exchange.publish(message.payload,:routing_key => message.route)
         EM.add_timer(1, Proc.new { close}) if close
       end

data/lib/runtime/{message.rb → workflow_step_messsage.rb}

@@ -3,20 +3,20 @@ require 'json/ext'
 
 module Factor
   module Runtime
-    class Message
-      attr_accessor :body, :workflow, :workflow_instance_id, :activity_instance_id, :last_activity_instance_id, :position
+    class WorkflowStepMessage
+      attr_accessor :body, :workflow, :workflow_instance_id, :step_id, :last_step_id, :position
       def initialize
-        @activity_instance_id=SecureRandom.hex
-        @workflow = workflow
+        @step_id=SecureRandom.hex
+        # @workflow = workflow
         @body = Hash.new
         @position = Array.new
       end
     
       def respond(params, event)
-        m = Message.new
+        m = WorkflowStepMessage.new
         m.body = @body
         m.workflow_instance_id=@workflow_instance_id
-        m.last_activity_instance_id = @activity_instance_id
+        m.last_step_id = @step_id
         m.workflow = @workflow
         m.position = @position
         m.position << "on"
@@ -25,11 +25,9 @@ module Factor
         m
       end
     
-    
       def add_values(values)
         current=@body
         position.each do |key|
-          #puts "[add value] #{key} (#{key.class.name})"
           current[key]={} if !current.include?(key)
           current=current[key]
         end
@@ -40,25 +38,24 @@ module Factor
       end
     
       def route
-        "#{workflow}.#{position.join('.')}"
+        # "#{workflow}.#{position.join('.')}"
+        "workflow"
       end
     
       def payload
         JSON.generator = JSON::Ext::Generator
-        obj = {"body"=>@body, "workflow_instance_id"=>@workflow_instance_id, "activity_instance_id"=>@activity_instance_id, "last_activity_instance_id"=>@last_activity_instance_id}
+        obj = {"body"=>@body, "workflow_instance_id"=>@workflow_instance_id, "step_id"=>@step_id, "last_step_id"=>@last_step_id, "workflow"=>@workflow,"position"=>@position}
         JSON.generate(obj)
       end
     
-      def from_queue routing_key, payload
-        routing_array=routing_key.split('.')
-        @workflow=routing_array.first #first
-        @position=routing_array.drop(1) # everything after first
-      
+      def from_queue payload
         message=JSON.parse(payload)
+        @workflow = message["workflow"]
+        @position=message["position"]
         @body=message["body"]
         @workflow_instance_id=message["workflow_instance_id"]
-        @activity_instance_id=message["activity_instance_id"]
-        @last_activity_instance_id=message["last_activity_instance_id"]
+        @step_id=message["step_id"]
+        @last_step_id=message["last_step_id"]
       end
     
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: factor
 version: !ruby/object:Gem::Version
-  version: 0.1.09
+  version: 0.1.10
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-21 00:00:00.000000000 Z
+date: 2013-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -133,6 +133,7 @@ files:
 - lib/channel/activity.rb
 - lib/channel/channel.rb
 - lib/channel/event.rb
+- lib/channel/listener.rb
 - lib/channel/trigger.rb
 - lib/cli/channel_task.rb
 - lib/cli/command.rb
@@ -144,10 +145,11 @@ files:
 - lib/factor.rb
 - lib/runtime/attributes.rb
 - lib/runtime/engine.rb
-- lib/runtime/message.rb
+- lib/runtime/listener_message.rb
 - lib/runtime/message_bus.rb
 - lib/runtime/workflow.rb
 - lib/runtime/workflow_instance.rb
+- lib/runtime/workflow_step_messsage.rb
 - bin/factor
 homepage: http://rubygems.org/gems/factor
 licenses: []