factor 0.6.3 → 0.6.4

data/lib/listener.rb

@@ -1,26 +0,0 @@
-# encoding: UTF-8
-
-require 'websocket_manager'
-
-module Factor
-  # Class Listener for integrating with connector service
-  class Listener
-    def initialize(url)
-      @url = url
-    end
-
-    def listener(listener_id)
-      listen("#{@url}/listeners/#{listener_id}")
-    end
-
-    def action(action_id)
-      listen("#{@url}/actions/#{action_id}")
-    end
-
-    private
-
-    def listen(uri_path)
-      WebSocketManager.new(uri_path)
-    end
-  end
-end

data/lib/runtime.rb

@@ -1,232 +0,0 @@
-# encoding: UTF-8
-
-require 'json'
-require 'securerandom'
-require 'yaml'
-require 'eventmachine'
-require 'uri'
-require 'faye/websocket'
-require 'ostruct'
-
-require 'listener'
-require 'commands/base'
-
-module Factor
-  # Runtime class is the magic of the server
-  class Runtime
-    attr_accessor :logger, :name, :description, :id, :instance_id, :connectors, :credentials
-
-    def initialize(connectors, credentials)
-      @workflow_spec  = {}
-      @sockets        = []
-      @instance_id    = SecureRandom.hex(3)
-      @reconnect      = true
-
-      trap 'SIGINT' do
-        info "Exiting '#{@instance_id}'"
-        @reconnect = false
-        @sockets.each { |s| s.close }
-        exit
-      end
-
-      @connectors = {}
-      flat_hash(connectors).each do |key, connector_url|
-        @connectors[key] = Listener.new(connector_url)
-      end
-
-      @credentials = {}
-      credentials.each do |connector_id, credential_settings|
-        @credentials[connector_id] = credential_settings
-      end
-    end
-
-    def load(workflow_definition)
-      EM.run do
-        instance_eval(workflow_definition)
-      end
-    end
-
-    def listen(service_ref, params = {}, &block)
-      service_map = service_ref.split('::') 
-      service_id = service_map.first
-      listener_id = service_map.last
-      service_key = service_map[0..-2].map{|k| k.to_sym}
-
-      ws = @connectors[service_key].listener(listener_id)
-
-      handle_on_open(service_ref, 'Listener', ws, params)
-
-      ws.on :close do
-        error 'Listener disconnected'
-        if @reconnect
-          warn 'Reconnecting...'
-          sleep 3
-          ws.open
-        end
-      end
-
-      ws.on :message do |event|
-        listener_response = JSON.parse(event.data)
-        case listener_response['type']
-        when'start_workflow'
-          success "Workflow '#{service_id}::#{listener_id}' triggered"
-          error_handle_call(listener_response, &block)
-        when 'return'
-          success "Workflow '#{service_ref}' started"
-        when 'fail'
-          error "Workflow '#{service_ref}' failed to start"
-        when 'log'
-          listener_response['message'] = "  #{listener_response['message']}"
-          log_message(listener_response)
-        else
-          error "Unknown listener response: #{listener_response}"
-        end
-      end
-
-      ws.on :retry do |event|
-        warn event[:message]
-      end
-
-      ws.on :error do |event|
-        err = 'Error during WebSocket handshake: Unexpected response code: 401'
-        if event.message == err
-          error "Sorry but you don't have access to this listener,
-            | either because your token is invalid or your plan doesn't
-            | support this listener"
-        else
-          error 'Failure in WebSocket connection to connector service'
-        end
-      end
-
-      ws.open
-
-      @sockets << ws
-    end
-
-    def run(service_ref, params = {}, &block)
-      service_map = service_ref.split('::') 
-      service_id = service_map.first
-      action_id = service_map.last
-      service_key = service_map[0..-2].map{|k| k.to_sym}
-
-      ws = @connectors[service_key].action(action_id)
-
-      handle_on_open(service_ref, 'Action', ws, params)
-
-      ws.on :error do
-        error 'Connection dropped while calling action'
-      end
-
-      ws.on :message do |event|
-        action_response = JSON.parse(event.data)
-        case action_response['type']
-        when 'return'
-          ws.close
-          success "Action '#{service_ref}' responded"
-          error_handle_call(action_response, &block)
-        when 'fail'
-          ws.close
-          error "  #{action_response['message']}"
-          error "Action '#{service_ref}' failed"
-        when 'log'
-          action_response['message'] = "  #{action_response['message']}"
-          log_message(action_response)
-        else
-          error "Unknown action response: #{action_response}"
-        end
-      end
-
-      ws.open
-
-      @sockets << ws
-    end
-
-    private
-
-    class DeepStruct < OpenStruct
-      def initialize(hash=nil)
-        @table = {}
-        @hash_table = {}
-
-        if hash
-          hash.each do |k,v|
-            @table[k.to_sym] = (v.is_a?(Hash) ? self.class.new(v) : v)
-            @hash_table[k.to_sym] = v
-
-            new_ostruct_member(k)
-          end
-        end
-      end
-
-      def to_h
-        @hash_table
-      end
-
-      def [](idx)
-        hash = marshal_dump
-        hash[idx.to_sym]
-      end
-    end
-
-    def simple_object_convert(item)
-      if item.is_a?(Hash)
-        DeepStruct.new(item)
-      elsif item.is_a?(Array)
-        item.map do |i|
-          simple_object_convert(i)
-        end
-      else
-        item
-      end
-    end
-
-    def flat_hash(h,f=[],g={})
-      return g.update({ f=>h }) unless h.is_a? Hash
-      h.each { |k,r| flat_hash(r,f+[k],g) }
-      g
-    end
-
-    def handle_on_open(service_ref, dsl_type, ws, params)
-      service_map = service_ref.split('::') 
-      service_id = service_map.first
-
-      ws.on :open do
-        params.merge!(@credentials[service_id.to_sym] || {})
-        success "#{dsl_type.capitalize} '#{service_ref}' called"
-        ws.send(params.to_json)
-      end
-    end
-
-    def error_handle_call(listener_response, &block)
-      content = simple_object_convert(listener_response['payload'])
-      block.call(content) if block
-    rescue => ex
-      error "Error in workflow definition: #{ex.message}"
-      ex.backtrace.each do |line|
-        error "  #{line}"
-      end
-    end
-
-    def success(msg)
-      log_message('type' => 'log', 'status' => 'success', 'message' => msg)
-    end
-
-    def warn(msg)
-      log_message('type' => 'log', 'status' => 'warn', 'message' => msg)
-    end
-
-    def error(msg)
-      log_message('type' => 'log', 'status' => 'error', 'message' => msg)
-    end
-
-    def info(msg)
-      log_message('type' => 'log', 'status' => 'info', 'message' => msg)
-    end
-
-    def log_message(message_info)
-      message_info['instance_id'] = @instance_id
-      message_info['workflow_id'] = @id
-      @logger.call(message_info) if @logger
-    end
-  end
-end

data/spec/base_spec.rb

@@ -1,102 +0,0 @@
-# encoding: UTF-8
-
-require 'spec_helper'
-require 'tempfile'
-require 'yaml'
-require 'commander'
-
-describe Factor::Commands::Command do
-  before :each do
-    @command = Factor::Commands::Command.new
-  end
-
-  output_methods = %w(info warn error success)
-
-  output_methods.each do |method_name|
-    describe ".#{method_name}" do
-      it "logs #{method_name}" do
-
-        test_string = 'Hello World'
-        output = capture_stdout do
-          @command.method(method_name.to_sym).call message: test_string
-        end
-
-        expect(output).to include(test_string)
-        expect(output).to include(method_name.upcase)
-      end
-    end
-  end
-
-  describe '.exception' do
-    it 'logs exception' do
-
-      test_string = 'Hello World'
-      exception_string = 'Something be busted'
-      output = capture_stdout do
-        begin
-          fail ArgumentError, exception_string
-        rescue => ex
-          @command.exception test_string, ex
-        end
-      end
-
-      expect(output).to include(test_string)
-      expect(output).to include(exception_string)
-      expect(output).to include('ERROR')
-
-    end
-  end
-
-  describe '.load_config' do
-    it 'can load credentials and connectors' do
-      credentials_file = Tempfile.new('credentials')
-      connectors_file = Tempfile.new('connectors')
-
-      credentials_content = {
-        'github' => {
-          'api_key' => 'fake_github_key'
-        },
-        'heroku' => {
-          'api_key' => 'fake_heroku_key'
-        }
-      }
-
-      connectors_content = {
-        'timer'   => 'http://localhost:9294/v0.4/timer',
-        'web'     => 'http://localhost:9294/v0.4/web',
-        'github'  => 'http://localhost:9294/v0.4/github',
-        'heroku'  => 'http://localhost:9294/v0.4/heroku'
-      }
-
-      credentials_file.write(YAML.dump(credentials_content))
-      connectors_file.write(YAML.dump(connectors_content))
-
-      credentials_file.rewind
-      connectors_file.rewind
-
-      options = Commander::Command::Options.new
-      options.credentials = credentials_file.path
-      options.connectors  = connectors_file.path
-
-      config_settings = {
-        credentials: options.credentials,
-        connectors:  options.connectors
-      }
-
-      output = capture_stdout do
-        @command.load_config config_settings
-      end
-
-      expect(configatron.credentials.github.api_key).to eq('fake_github_key')
-      expect(configatron.credentials.heroku.api_key).to eq('fake_heroku_key')
-      connectors_content.keys.each do |expected_connector_key|
-        actual_connector   = configatron.connectors[expected_connector_key]
-        expected_connector = connectors_content[expected_connector_key]
-        expect(actual_connector).to eq(expected_connector)
-      end
-
-      credentials_file.close
-      connectors_file.close
-    end
-  end
-end

data/spec/listener_spec.rb

@@ -1,9 +0,0 @@
-# encoding: UTF-8
-
-require 'spec_helper'
-
-describe Factor::Listener do
-  it 'does stuff' do
-    expect(true).to eq(true)
-  end
-end

data/spec/workflow_spec.rb

@@ -1,11 +0,0 @@
-# encoding: UTF-8
-
-require 'spec_helper'
-
-describe Factor::Commands::Workflow do
-  describe '.server' do
-    it 'can run a basic workflow' do
-
-    end
-  end
-end