factor 0.6.3 → 0.6.4

data/lib/logger/logger.rb

@@ -0,0 +1,28 @@
+
+module Factor
+  module Log
+
+    class Logger
+
+      def log
+        raise NotImplemented
+      end
+
+      def info
+        raise NotImplemented
+      end
+
+      def warn
+        raise NotImplemented
+      end
+
+      def error
+        raise NotImplemented
+      end
+
+      def time
+        Time.now.localtime.strftime('%m/%d/%y %T.%L')
+      end
+    end
+  end
+end

data/lib/runtime/exec_handler.rb

@@ -0,0 +1,16 @@
+module Factor
+  module Runtime
+    class ExecHandler
+      attr_accessor :params, :service, :fail_block
+
+      def initialize(service = nil, params = {})
+        @service = service
+        @params = params
+      end
+
+      def on_fail(&block)
+        @fail_block = block
+      end
+    end
+  end
+end

data/lib/runtime/service_address.rb

@@ -0,0 +1,46 @@
+module Factor
+  module Runtime
+    class ServiceAddress < Array
+      def initialize(service_ref)
+        if service_ref.is_a?(String)
+          service_map = service_ref.split('::')
+          raise ArgumentError, 'Address must not be empty' if service_ref.empty?
+          raise ArgumentError, 'Address must contain at least one value' unless service_map.count > 0
+          raise ArgumentError, 'Address must contain at least one value' unless service_map.all?{|i| !i.empty?}
+          super service_map
+        elsif service_ref.is_a?(ServiceAddress) || service_ref.is_a?(Array)
+          raise ArgumentError, 'All elements in array must be a string' unless service_ref.all?{|i| i.is_a?(String)}
+          super service_ref
+        else
+          raise ArgumentError, 'Address must be a String, Array, or ServiceAddress'
+        end
+      end
+
+      def workflow?
+        self.service == 'workflow'
+      end
+
+      def service
+        self.first
+      end
+
+      def namespace
+        raise ArgumentError, 'Address must contain at least two parts' unless self.count >= 2
+        self[0..-2].map{|k| k.to_sym}
+      end
+
+      def id
+        self.last
+      end
+
+      def to_s
+        self.join('::')
+      end
+
+      def workflow_address
+        workflow_service_map = self[1..-1]
+        ServiceAddress.new workflow_service_map
+      end
+    end
+  end
+end

data/lib/runtime/service_caller.rb

@@ -0,0 +1,105 @@
+require 'websocket_manager'
+require 'eventmachine'
+
+module Factor
+  module Runtime
+    class ServiceCaller
+      attr_accessor :reconnect, :retry_period
+
+      def initialize(connector_url, options = {})
+        @url = connector_url
+        @subscribers = {}
+        @reconnect = options[:reconnect] || true
+        @retry_period = options[:retry_period] || 5
+        @retry_count = 0
+        @offline_duration = 0
+      end
+
+      def listen(listener_id, params={})
+        @reconnect = true
+        call("#{@url}/listeners/#{listener_id}", params)
+      end
+
+      def action(action_id, params={})
+        @reconnect = false
+        call("#{@url}/actions/#{action_id}", params)
+      end
+
+      def close
+        @ws.close
+      end
+
+      def on(event, &block)
+        @subscribers ||= {}
+        @subscribers[event.to_sym] ||= []
+        @subscribers[event.to_sym] << block
+      end
+
+      private
+
+      def start(params)
+        @ws.open
+        @ws.send(params)
+      end
+
+      def retry_connection(params)
+        @retry_count += 1
+        notify :retry, count: @retry_count, offline_duration: @offline_duration
+        @offline_duration += @retry_period
+
+        EM.next_tick{
+          sleep @retry_period
+          start(params)
+        }
+      end
+
+      def call(url, params={})
+        @ws = Factor::WebSocketManager.new(url)
+
+        @ws.on :open do
+          @retry_count = 0
+          @offline_duration = 0
+          notify :open
+        end
+
+        @ws.on :close do
+          notify :close if @retry_count == 0
+          retry_connection(params) if @reconnect
+        end
+
+        @ws.on :error do
+          notify :fail, message: 'Connection dropped while calling action'
+        end
+
+        @ws.on :message do |event|
+          action_response = JSON.parse(event.data)
+          case action_response['type']
+          when 'return'
+            notify :return, action_response['payload']
+          when 'fail'
+            @ws.close
+            notify :log, status:'error', message: "  #{action_response['message']}"
+            notify :fail
+          when 'log'
+            message = "  #{action_response['message']}"
+            notify :log, status: action_response['status'], message: message
+          when 'start_workflow'
+            notify :start_workflow, action_response
+          else
+            notify :log, status:'error', message: "Unknown action response: #{action_response}"
+          end
+        end
+
+        start(params)
+      end
+
+      def notify(event, params={})
+        if @subscribers[event]
+          @subscribers[event].each do |block|
+            EM.next_tick { block.call(params) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/runtime/workflow.rb

@@ -0,0 +1,170 @@
+# encoding: UTF-8
+
+require 'securerandom'
+require 'eventmachine'
+
+require 'commands/base'
+require 'common/deep_struct'
+require 'runtime/service_caller'
+require 'runtime/service_address'
+require 'runtime/exec_handler'
+
+module Factor
+  module Runtime
+    class Workflow
+      attr_accessor :name, :description, :id, :instance_id, :connectors, :credentials
+
+      def initialize(connectors, credentials, options={})
+        @workflow_spec  = {}
+        @workflows      = {}
+        @instance_id    = SecureRandom.hex(3)
+        @reconnect      = true
+        @logger         = options[:logger] if options[:logger]
+
+        @connectors = Factor::Common.flat_hash(connectors)
+        @credentials = credentials
+      end
+
+      def load(workflow_definition)
+        begin
+          EM.run do
+            instance_eval(workflow_definition)
+          end
+        rescue Interrupt
+        end
+      end
+
+      def listen(service_ref, params = {}, &block)
+        address = ServiceAddress.new(service_ref)
+        e = ExecHandler.new(service_ref, params)
+        connector_url = @connectors[address.namespace]
+
+        if !connector_url
+          error "Listener '#{address}' not found"
+          e.fail_block.call({}) if e.fail_block
+        else
+          caller = ServiceCaller.new(connector_url)
+
+          caller.on :close do
+            error "Listener '#{address}' disconnected"
+          end
+
+          caller.on :open do
+            info "Listener '#{address}' starting"
+          end
+
+          caller.on :retry do |retry_info|
+            if retry_info
+              details = " ("
+              details << "retry #{retry_info[:count]}"
+              details << ", offline for #{retry_info[:offline_duration]} seconds" if retry_info[:offline_duration] > 0
+              details << ")"
+            end
+            warn "Listener '#{address}' reconnecting#{details || ''}"
+          end
+
+          caller.on :error do
+            error "Listener '#{address}' dropped the connection"
+          end
+
+          caller.on :return do |data|
+            success "Listener '#{address}' started"
+          end
+
+          caller.on :start_workflow do |data|
+            success "Listener '#{address}' triggered"
+            block.call(Factor::Common.simple_object_convert(data))
+          end
+
+          caller.on :fail do |info|
+            error "Listener '#{address}' failed"
+            e.fail_block.call(action_response) if e.fail_block
+          end
+
+          caller.on :log do |log_info|
+            @logger.log log_info[:status], log_info
+          end
+
+          caller.listen(address.id,params)
+        end
+        e
+      end
+
+      def workflow(service_ref, &block)
+        address = ServiceAddress.new(service_ref)
+        @workflows ||= {}
+        @workflows[address] = block
+      end
+
+      def run(service_ref, params = {}, &block)
+        address = ServiceAddress.new(service_ref)
+        e = ExecHandler.new(service_ref, params)
+
+        if address.workflow?
+          workflow_address = address.workflow_address
+          workflow = @workflows[workflow_address]
+
+          if workflow
+            success "Workflow '#{workflow_address}' starting"
+            content = Factor::Common.simple_object_convert(params)
+            workflow.call(content)
+            success "Workflow '#{workflow_address}' started"
+          else
+            error "Workflow '#{workflow_address}' not found"
+            e.fail_block.call({}) if e.fail_block
+          end
+        else
+          connector_url = @connectors[address.namespace]
+          caller = ServiceCaller.new(connector_url)
+
+          caller.on :open do
+            info "Action '#{address}' starting"
+          end
+
+          caller.on :error do
+            error "Action '#{address}' dropped the connection"
+          end
+
+          caller.on :return do |data|
+            success "Action '#{address}' responded"
+            caller.close
+            block.call(Factor::Common.simple_object_convert(data))
+          end
+
+          caller.on :close do
+            error "Action '#{address}' disconnected"
+            e.fail_block.call(action_response) if e.fail_block
+          end
+
+          caller.on :fail do |info|
+            error "Action '#{address}' failed"
+            e.fail_block.call(action_response) if e.fail_block
+          end
+
+          caller.on :log do |log_info|
+            @logger.log log_info[:status], log_info
+          end
+
+          caller.action(address.id,params)
+        end
+        e
+      end
+
+      def success(message)
+        @logger.success message
+      end
+
+      def info(message)
+        @logger.info message
+      end
+
+      def warn(message)
+        @logger.warn message
+      end
+
+      def error(message)
+        @logger.error message
+      end
+    end
+  end
+end

data/lib/websocket_manager.rb

@@ -2,6 +2,7 @@
 
 require 'faye/websocket'
 require 'uri'
+require 'json'
 
 module Factor
   # class for managing the web socket connections
@@ -54,7 +55,7 @@ module Factor
     end
 
     def send(msg)
-      @ws.send(msg)
+      @ws.send(msg.to_json)
     end
 
     private

data/spec/spec_helper.rb

@@ -7,13 +7,6 @@ CodeClimate::TestReporter.start do
   add_filter '/spec/'
 end
 
-# include anything that could be tested
-require 'commands/base'
-require 'commands/workflows'
-require 'listener'
-require 'runtime'
-require 'websocket_manager'
-
 $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
 
 def capture_stdout(&_block)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: factor
 version: !ruby/object:Gem::Version
-  version: 0.6.3
+  version: 0.6.4
 platform: ruby
 authors:
 - Maciej Skierkowski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-30 00:00:00.000000000 Z
+date: 2014-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: commander
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.5
+        version: 0.8.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.5
+        version: 0.8.0
 - !ruby/object:Gem::Dependency
   name: colored
   requirement: !ruby/object:Gem::Requirement
@@ -144,19 +144,20 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- "./spec/base_spec.rb"
-- "./spec/listener_spec.rb"
-- "./spec/registry_spec.rb"
 - "./spec/spec_helper.rb"
-- "./spec/workflow_spec.rb"
 - bin/factor
+- lib/commands.rb
 - lib/commands/base.rb
-- lib/commands/registry.rb
-- lib/commands/workflows.rb
-- lib/factor.rb
+- lib/commands/registry_command.rb
+- lib/commands/workflow_command.rb
+- lib/common/deep_struct.rb
 - lib/factor/version.rb
-- lib/listener.rb
-- lib/runtime.rb
+- lib/logger/basic.rb
+- lib/logger/logger.rb
+- lib/runtime/exec_handler.rb
+- lib/runtime/service_address.rb
+- lib/runtime/service_caller.rb
+- lib/runtime/workflow.rb
 - lib/websocket_manager.rb
 homepage: https://factor.io
 licenses: []
@@ -182,8 +183,4 @@ signing_key:
 specification_version: 4
 summary: CLI to manager workflows on Factor.io
 test_files:
-- "./spec/base_spec.rb"
-- "./spec/listener_spec.rb"
-- "./spec/registry_spec.rb"
 - "./spec/spec_helper.rb"
-- "./spec/workflow_spec.rb"