factor 0.1.10 → 0.3.1

data/lib/channel/listener.rb

@@ -5,7 +5,7 @@ module Factor
     class Listener
       attr_accessor :workflow_id, :event
 
-      def start(params,&code)
+      def start(user_id,channel_name,listener_name,event,workflow_name,params,&code)
       end
 
       def stop()

data/lib/cli/channel_task.rb

@@ -1,36 +1,34 @@
 require 'rubygems'
 require 'cli/command'
-require 'zip/zip'
-require 'zip/zipfilesystem'
 
 module Factor
   module CLI
     class ChannelTask < Command
-
-      desc "call CHANNEL METHOD TARGET","start a workflow"
-      method_option :parameters, :type=>:hash, :default=>{}, :required=>false
-      def call(channel, method, target)
-        
-        puts "not implemented"
-
-      end
-  
-      
-      
       desc "list", "list all the channels"
       #method_option :key, :alias=>"-k", :type=>:string, :desc=>"key reference"
       def list
-        puts @client.get_channels
+        @client.get_channels().each do |channel|
+          puts "#{channel['name']} (#{channel['slug']})"
+          puts "  Listeners:" if channel['listeners'].count>0
+          channel['listeners'].each do |listener|
+            puts "    #{listener['name']}: #{listener['description']}"
+          end
+          puts "  Actions:" if channel['actions'].count>0
+          channel['actions'].each do |action|
+            puts "    #{action['name']}: #{action['description']}"
+          end
+        end
       end
     
-      desc "add DIRECTORY DEFINITION", "add a key and value for the credential"
-      def add(directory,definition_file)
-        puts @client.add_channel(directory,definition_file)
+      desc "create DIRECTORY DEFINITION", "add a key and value for the credential"
+      method_option :organization, :alias=>"-o", :type=>:string, :desc=>"Organizoation to which this workflow belongs"
+      def create(directory,definition_file)
+        puts @client.create_channel(directory,definition_file,options[:organization])["notice"]
       end
     
-      desc "remove NAME", "remove a workflow"
-      def remove(name)
-        puts @client.remove_channel(name)
+      desc "delete NAME", "remove a workflow"
+      def delete(name)
+        puts @client.delete_channel(name)["notice"]
       end
   
 

data/lib/cli/command.rb

@@ -16,7 +16,7 @@ module Factor
         def initialize(*vals)
           @config_file_dir = File.expand_path("~/.factor") 
           @client = Factor::Client::Client.new
-          @client.login_token(get_config[:token])
+          @client.login_token(get_config['token'])
           super(*vals)
         end
         
@@ -24,7 +24,7 @@ module Factor
           File.open(@config_file_dir,'w') do |file|
             YAML::dump(config,file)
           end
-          @client.login_token(get_config[:token])
+          @client.login_token(get_config['token'])
         end
     
         def get_config
@@ -33,4 +33,4 @@ module Factor
       end
     end
   end
-end
+end

data/lib/cli/credential_task.rb

@@ -6,24 +6,32 @@ module Factor
     class CredentialTask < Command
 
     
-      desc "set SERVICE NAME VALUE", "add a key and value for the credential"
+      desc "create SERVICE NAME VALUE", "add a key and value for the credential"
       method_option :key, :type=>:string, :desc=>"File reference containing the symmetric key for encryption"
-      def set(service,name,value)
-        securet=nil
+      method_option :organization, :type=>:string, :desc=>"Organizoation to which this credential belongs"
+      def create(service,name,value)
+        secret=nil
         if options[:key]
           secret=File.read(options[:key])
         end
-        puts @client.set_credential(service,name,value,secret)
+        puts @client.create_credential(service,name,value,secret,options[:organization])
       end
 
       desc "list", "get all of the credential"
       def list()
-        puts @client.get_credentials()
+        @client.get_credentials["value"].each do |service,values|
+          # puts "#{credential['service']} : #{credential['name']} (#{credential['slug']}): #{credential['value']}"
+          puts "#{service}:"
+          values.each do |key,values|
+          #   puts "#{key['value']} (#{value['slug']}) : #{value}"
+            puts "  #{key} (#{values['slug']}): ***"
+          end
+        end
       end
     
-      desc "remove SERVICE NAME", "remove a value from the credentials bag"
-      def remove(service,name)
-        puts @client.remove_credential(service,name)
+      desc "delete SERVICE NAME", "remove a value from the credentials bag"
+      def delete(service,name)
+        puts @client.delete_credential(service,name)
       end
     
     end

data/lib/cli/factor_task.rb

@@ -1,6 +1,5 @@
 require 'rubygems'
 require 'cli/command'
-require 'cli/server_task'
 require 'cli/workflow_task'
 require 'cli/credential_task'
 require 'cli/channel_task'
@@ -14,15 +13,14 @@ module Factor
       # method_option :token, :alias=>"-t", :type=>:string, :desc=>"Token value to set", :required=>true
       def login(email,token)
         config = get_config
-        config[:email]=email
-        config[:token]=token
+        config['email']=email
+        config['token']=token
         save_config(config)
       end
     end
   end
 end
 
-Factor::CLI::FactorTask.register(Factor::CLI::ServerTask, "server","server","start and list servers")
 Factor::CLI::FactorTask.register(Factor::CLI::WorkflowTask,"workflow","workflow","start and list workflows")
 Factor::CLI::FactorTask.register(Factor::CLI::ChannelTask,"channel","channel","install,uninstall, list channels")
 Factor::CLI::FactorTask.register(Factor::CLI::CredentialTask,"credential","credential","manage remote credential store")

data/lib/cli/workflow_task.rb

@@ -4,53 +4,43 @@ require 'cli/command'
 module Factor
   module CLI
     class WorkflowTask < Command
-  
-      desc "call WORKFLOW","start a workflow"
-      method_option :parameters, :type=>:hash, :default=>{}, :required=>false
-      def call(workflow_name)
-        puts "starting workflow #{workflow_name} with options #{options.parameters.to_s}"
-    
-        engine = Factor::Runtime::Engine.new(get_config[:email],get_config[:token])
-        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)
+
+      desc "start WORKFLOW","start listener for workflow"
+      def start(workflow_name)
+        puts @client.start_workflow(workflow_name)["notice"]
       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)
+        puts @client.stop_workflow(workflow_name)["notice"]
+      end
+
+      desc "call WORKFLOW","call workflow"
+      method_option :parameters, :type=>:hash, :default=>{}, :required=>false
+      def call(workflow_name)
+        puts @client.call_workflow(workflow_name,options[:parameters])["notice"]
       end
       
       
       desc "list", "list all the workflows"
-      #method_option :key, :alias=>"-k", :type=>:string, :desc=>"key reference"
       def list
-        puts @client.get_workflows
+        @client.get_workflows().each do |workflow|
+          puts "#{workflow['name']} (#{workflow['slug']})"
+        end
       end
     
-      desc "add NAME FILENAME", "add a key and value for the credential"
+      desc "create NAME FILENAME", "add a key and value for the credential"
       #method_option :key, :alias=>"-k", :type=>:string, :desc=>"key reference"
-      #method_option :value, :alias=>"-v", :type=>:string, :desc=>"values"
-      def add(name,filename)
+      method_option :organization, :alias=>"-v", :type=>:string, :desc=>"Organizoation to which this workflow belongs"
+      def create(name,filename)
         contents=File.open(File.expand_path(filename), "rb") {|f| f.read}
-        puts @client.add_workflow(name,contents)
+        puts @client.create_workflow(name,contents,options[:organization])["notice"]
       end
     
-      # desc "remove NAME", "remove a workflow"
-      # def remove(name)
-      #   puts @client.remove_workflow(name)
-      # end
+      desc "delete NAME", "remove a workflow"
+      def delete(name)
+        puts @client.delete_workflow(name)
+      end
       
       
       

data/lib/client/client.rb

@@ -7,6 +7,7 @@ require 'open-uri'
 require 'digest/sha2'
 require 'openssl'
 require 'base64'
+require 'json'
 
 
 module Factor
@@ -19,102 +20,11 @@ module Factor
         @host=host
       end
     
-      def register(email,password)
-      end
-    
-      def login(email, password)
-      end
-    
       def login_token(token)
         @token=token
       end
     
-      def load_workflows(engine,&code)
-        code.call("downloading workflow list") 
-        workflows = rest_get("workflows")
-        code.call("downloaded #{workflows.size} workflows") 
-        workflows.each do |workflow_info|
-          code.call("parsing '#{workflow_info['name']}'") 
-          workflow_definition = JSON.parse(workflow_info['definition'])
-          code.call("loading '#{workflow_info['name']}' into runtime") 
-          workflow=Factor::Runtime::Workflow.new(workflow_definition)
-          engine.load_workflow(workflow)
-          code.call("loading complete for '#{workflow_info['name']}'") 
-        end
-        engine
-      end
-    
-      def load_credentials(engine,secret=nil,&code)
-        code.call("downloading credential list")
-        credentials = rest_get("credentials")["value"]
-        code.call("loading credentials")
-
-        if secret
-          code.call("decrypting credentials")
-          decrypter = OpenSSL::Cipher.new("AES-256-CFB")
-          sha256= Digest::SHA2.new(256)
-          decrypter.key=Base64.encode64(sha256.digest(secret))
-          decrypter.decrypt
-          credentials.each do |service,creds|
-            creds.each do |credential,value|
-              if value["encrypted"]
-                decrypted = decrypter.update(Base64.decode64(value["value"])) + decrypter.final
-                credentials[service][credential]["value"]=decrypted
-                credentials[service][credential]["encrypted"]=false
-              end
-            end
-          end  
-          code.call("decrypting credentials complete")
-        end
-
-        engine.load_credentials(credentials)
-      
-        engine
-      end
-    
-      def load_channels(engine,&code)
-      
-        # get list of channels
-        code.call("downloading channels list")
-        channels = rest_get("channels")
-      
-        #load each channel
-        channels.each do |channel|
-          if !channel['zip_url'].empty?
-            code.call("downloading '#{channel['zip_url']}'")
-            # URI of the zip file containing the module
-            uri = URI.parse(channel['zip_url'])
-          
-            # temp file to store the zip for download
-            #temp_file = Tempfile.new([uri.path.gsub(/\W+/,'-'), '.zip'], :encoding => 'ascii-8bit')
-            temp_file = Tempfile.new([uri.to_s.gsub(/\W+/,'-'), '.zip'])
-          
-            # temp directory where zip will be decompressed
-            unzip_dir=temp_file.path[0..-5]
-          
-            # download
-            open(uri.to_s,"rb") do |bin|
-              temp_file.print bin.read
-            end
-            temp_file.close
-          
-            code.call("unzipping '#{channel['name']}'")
-            # unzip download zip into unzipped directory
-            unzip(temp_file.path,unzip_dir)
-          
-            filename = unzip_dir + "/" + channel['module_name'].split(/(?=[A-Z])/).map{ |x| x.downcase }.join('_') + ".rb"
-            
-            code.call("loading '#{channel["name"]}' into engine")
-            engine.load_channel(filename, channel)
-          end
-        end
-      
-      
-        engine
-      end
-    
-    
-      def set_credential(service,name,value,secret=nil)
+      def create_credential(service,name,value,secret=nil,organization=nil)
         # this is a PUT not POST because it is technically editing, not creating a new one
         credential = {:service=>service,:name=>name,:value=>value}
 
@@ -129,49 +39,65 @@ module Factor
           credential[:value]=encrypted
           credential[:encrypted]=true
         end
-
-        rest_post("credentials",credential)
+        path = !!organization ? "organizations/#{organization}/credentials" : "credentials"
+        rest_post(path,credential)
       end
       
       def get_credentials()
         rest_get("credentials")
       end
       
-      def remove_credential(service,name)
+      def delete_credential(service,name)
         rest_delete("credentials",{:service=>service,:name=>name})
       end
     
     
     
     
-      # workflows
-      def add_workflow(key,definition)
-        rest_post("workflows",{:workflow=>{:name=>key,:definition=>definition}})
+      # untested
+      def create_workflow(key,definition,organization=nil)
+        path = !!organization ? "organizations/#{organization}/workflows" : "workflows"
+        rest_post(path,{:workflow=>{:name=>key,:definition=>definition}})
       end
       
       def get_workflows()
         rest_get("workflows")
       end
       
-      # def remove_workflow(name="")
-      #   rest_delete("workflows",{:name=>name})
-      # end
+      def delete_workflow(workflow_name)
+        rest_delete("workflows/#{workflow_name}")
+      end
+
+      def start_workflow(workflow_name)
+        rest_get("workflows/#{workflow_name}/state")
+      end
+
+      def stop_workflow(workflow_name)
+        rest_delete("workflows/#{workflow_name}/state")
+      end
+
+      def call_workflow(workflow_name,params)
+        rest_get("workflows/#{workflow_name}/call",params)
+      end
+
       
       
       # channels
-      def add_channel(path,definition_file)
+      def create_channel(path,definition_file,organization=nil)
         file=zip(File.expand_path(path))
         definition = File.read(definition_file)
-        rest_post("channels",{:zip=>file,:channel=>{:definition=>definition}})
+
+        path = !!organization ? "organizations/#{organization}/channels" : "channels"
+        rest_post(path,{:zip=>file,:channel=>{:definition=>definition}})
       end
       
       def get_channels()
         rest_get("channels")
       end
       
-      # def remove_channel(name="")
-      #   rest_delete("channels",{:name=>name})
-      # end
+      def delete_channel(channel_name)
+        rest_delete("channels/#{channel_name}")
+      end
       
       
     
@@ -180,37 +106,6 @@ module Factor
     
       private
     
-      def fix_github_zip_archive(file)
-        Zip::ZipFile.open(file.path) do |zip|
-          basedir = zip.entries.first.name
-          zip.remove zip.entries.first
-          zip.each do |entry|
-            target = entry.name.sub(/^#{basedir}/,'')
-            if entry.directory?
-              zip.dir.mkdir(target)
-            else
-              zip.file.open(entry.name) do |istream|
-                zip.file.open(target, 'w') do |ostream|
-                  ostream.write istream.read
-                end
-              end
-            end
-            zip.remove entry
-          end
-        end
-      end
-    
-      def unzip(zip, unzip_dir, remove_after = false)
-        Zip::ZipFile.open(zip) do |zip_file|
-          zip_file.each do |f|
-            f_path=File.join(unzip_dir, f.name)
-            FileUtils.mkdir_p(File.dirname(f_path))
-            zip_file.extract(f, f_path) unless File.exist?(f_path)
-          end
-        end
-        FileUtils.rm(zip) if remove_after
-      end
-      
       def zip(directory)
         path=directory.dup
         path.sub!(%r[/$],'')
@@ -223,35 +118,34 @@ module Factor
         end
         File.open(zip_path,'r')
       end
-    
+
       def rest_get(path,params={})
         params["auth_token"]=@token
         
         param_string=params.map{|key,value| "#{key}=#{value}"}.join("&")
-        
-        JSON.parse(RestClient.get("http://#{@host}/#{path}.json?#{param_string}"))
+        response=RestClient.get("http://#{@host}/#{path}.json?#{param_string}")
+        JSON.parse(response)
       end
       
       def rest_put(path,params={})
         params["auth_token"]=@token
-        
-        JSON.parse(RestClient.put("http://#{@host}/#{path}.json",params))
+        response=RestClient.put("http://#{@host}/#{path}.json",params)
+        JSON.parse(response)
       end
       
       def rest_post(path,params={})
-        #params["auth_token"]=@token
-        
-        JSON.parse(RestClient.post("http://#{@host}/#{path}.json?auth_token=#{@token}",params))
+        response=RestClient.post("http://#{@host}/#{path}.json?auth_token=#{@token}",params)
+        JSON.parse(response)
       end
       
       def rest_delete(path,params={})
         params["auth_token"]=@token
         
         param_string=params.map{|key,value| "#{key}=#{value}"}.join("&")
-        
-        JSON.parse(RestClient.delete("http://#{@host}/#{path}.json?#{param_string}"))
+        response=RestClient.delete("http://#{@host}/#{path}.json?#{param_string}")
+        JSON.parse(response)
       end
     
     end
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: factor
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.3.1
   prerelease: 
 platform: ruby
 authors:
@@ -59,38 +59,6 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 2.0.2
-- !ruby/object:Gem::Dependency
-  name: mustache
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 0.99.4
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 0.99.4
-- !ruby/object:Gem::Dependency
-  name: eventmachine
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 0.12.10
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 0.12.10
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -107,22 +75,6 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 1.7.6
-- !ruby/object:Gem::Dependency
-  name: amqp
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 0.9.8
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 0.9.8
 description: Friendly command-line interface and library for Factor
 email: maciej@factor.io
 executables:
@@ -139,17 +91,9 @@ files:
 - lib/cli/command.rb
 - lib/cli/credential_task.rb
 - lib/cli/factor_task.rb
-- lib/cli/server_task.rb
 - lib/cli/workflow_task.rb
 - lib/client/client.rb
 - lib/factor.rb
-- lib/runtime/attributes.rb
-- lib/runtime/engine.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: []
@@ -172,7 +116,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Factor.io Library and CLI

data/lib/cli/server_task.rb

@@ -1,82 +0,0 @@
-require 'rubygems'
-require 'cli/command'
-
-module Factor
-  module CLI
-    class ServerTask < Command
-      desc "start", "start the server"
-      method_option :tags, :alias=>"-t", :type=>:hash, :desc=>"Optional tags to identify from workflow"
-      method_option :channels, :type=>:array, :desc=>"Optional channel ruby file list for development"
-      method_option :verbose, :type=>:boolean, :desc=>"Display everything"
-      method_option :key, :type=>:string, :desc=>"File reference containing the symmetric key for encryption"
-      def start
-        engine = Factor::Runtime::Engine.new(get_config[:email],get_config[:token])
-        
-        options.tags.each {|tag,value| engine.tag(tag,value)} if options.tags?
-   
-        # load channels from server
-        say "loading channels from server" if options.verbose?
-        engine = @client.load_channels(engine) do |message|
-          say "  #{message}" if options.verbose?
-        end
-        
-        # load channels from files
-        if options.channels?
-          options.channels.each do |file|
-            full_file=File.expand_path(file)
-            say "  loading '#{full_file}'" if options.verbose?
-            engine.load_channel(full_file)
-            say "  loaded '#{full_file}'" if options.verbose?
-          end
-        end
-        
-        say "loading channels complete" if options.verbose?
-      
-      
-        # load workflows from server
-        say "loading workflows from server" if options.verbose?
-        engine = @client.load_workflows(engine) do |message|
-          say "  #{message}" if options.verbose?
-        end
-        say "loading workflows complete" if options.verbose?
-    
-        say "loading credentials from server" if options.verbose?
-        securet=nil
-        if options[:key]
-          secret=File.read(options[:key])
-        end
-        engine = @client.load_credentials(engine,secret) do |message|
-          say "  #{message}" if options.verbose?
-        end
-        say "loading credentials complete" if options.verbose?
-    
-        say "starting the server...", :green
-        message = engine.start
-        if message.is_a?(Exception)
-          say "[Unknown exception]", :red
-          say "  message:#{message}", :red
-          say "  backtrace:", :red
-          message.backtrace.each {|line| say "    #{line}", :red}
-        else
-          say "disconnecting...", :green
-        end
-        
-      end
-  
-      desc "list", "list all the running servers"
-      def list
-        say "listing all servers"
-      end
-  
-      desc "logs", "listen to incoming logs"
-      def logs
-        engine = Factor::Runtime::Engine.new(get_config[:email],get_config[:token])
-        say "Listening...", :green
-        engine.logs do |message|
-          say "[#{message.route}] #{JSON.pretty_generate(message.body)}"
-        end
-      end
-  
-    end
-  end
-end

data/lib/runtime/attributes.rb

@@ -1,26 +0,0 @@
-require 'rubygems'
-
-module Factor
-  module Runtime
-
-    class Attributes < Hash
-  
-      private
-      def map_values(map,values)
-        params=Hash.new
-        map.each do |key,reference|
-          params[key]=values[reference]
-        end
-        params
-      end
-  
-      def format_map(parent,map)
-        newmap=Hash.new
-        map.each do |key,value|
-          newmap["#{parent}::#{key}"]=value
-        end
-        newmap
-      end
-    end
-  end
-end

data/lib/runtime/engine.rb

@@ -1,256 +0,0 @@
-require 'rubygems'
-require 'factor'
-require 'mustache'
-#require 'facter'
-
-
-module Factor
-  module Runtime
-    class Engine
-      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={}
-        @channel_definitions=[]
-        @workflows = {}
-        @message_bus = MessageBus.new(username,token)
-        @credentials = {}
-        @tags = {}
-        @listeners={}
-      end
-    
-      def tag(key,value)
-        @tags[key]=value
-      end
-    
-      # load the channel by referencing the .rb file
-      # the filename is lowercase with "_" for spaces
-      # and the module inside must be camal cased to match
-      # once loaded it is in the channel_modules Hash
-      def load_channel filename, definition
-        filename = File.absolute_path(File.expand_path(filename.path)) if filename.is_a?(File) # just in case someone passes in a File not a String (i.e. me)
-        require filename
-        # channel_module_name = File.basename(filename).gsub('.rb','').split('_').map{|ea| ea.capitalize}.join('')
-        channel_module_name = definition['module_name']
-        channel_module= self.class.const_get(channel_module_name)
-        @channel_modules[channel_module_name]=channel_module  
-        @channel_definitions << definition
-      end
-    
-      def load_credentials credentials,secret=nil
-        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
-      # the object must be a Workflow type
-      def load_workflow workflow
-        @workflows[workflow.name] = workflow
-      end
-    
-      def logs routing_key="#", &code 
-        @message_bus.start do
-          @message_bus.listen routing_key do |message|
-            code.call message
-          end
-        end
-      end
-    
-      def send_start_workflow workflow, params, keep_open=false
-        instance_id=SecureRandom.hex
-        
-        @message_bus.start do
-          message = WorkflowStepMessage.new
-          message.position << "start"
-          message.workflow=workflow
-          message.add_values params
-          message.workflow_instance_id= instance_id
-          @message_bus.send message, !keep_open
-        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("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 = 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)
-                  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
-                  # 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
-          puts "done"
-        rescue Exception => 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_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 
-      
-      def get_channel_module(channel_name)
-        @channel_definitions.select { |channel_definition| channel_definition['name']==channel_name }.first['module_name']
-      end
-
-      # 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[type].each do |definition|
-              return definition["class_name"] if definition['name']==class_name
-            end
-          end
-        end
-      end
-
-      def render_template(source,values)
-        #params = Hash.new
-        
-        if source.is_a?(Hash)
-          params = Hash.new
-          source.each do |key,template|
-            params[key]=render_template(template,values)
-          end
-        else
-          params = Mustache.render(source,values)
-        end
-        
-        # activity_params.each do |key,template|
-        #   params[key]=Mustache.render(template,values)
-        # end
-        params
-      end
-      
-      # def match(target)
-      #   return true if target==nil || target==""
-      #   facts={}
-      #   #Facter.each {|k,v| facts[k]=v}
-      #   @tags.each {|k,v| facts[k]=v}
-      #   key,value=target.split("=")
-      #   facts[key]==value
-      # end
-      
-      
-    end
-  end
-end

data/lib/runtime/listener_message.rb

@@ -1,42 +0,0 @@
-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

@@ -1,59 +0,0 @@
-require 'rubygems'
-require 'eventmachine'
-require 'amqp'
-
-module Factor
-  module Runtime
-    class MessageBus
-      attr_accessor :host, :vhost, :username, :token, :connection, :channel, :exchange, :queue
-    
-      def initialize(email,token)
-        @host = "queue.factor.io"
-        @vhost = email
-        @username=email
-        @token=token
-      end
-      
-    
-      # 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="factor",&code)
-        EventMachine.run do
-          #connection_settings={:host=>@host,:user=>@username,:password=>@token,:vhost=>@vhost}
-          connection_settings={:host=>@host}
-          @connection = AMQP.connect(connection_settings)
-          @channel  = AMQP::Channel.new(connection)
-          @exchange = @channel.topic(topic,:auto_delete=>true) # new topic exchange
-          code.call
-        end
-      end
-    
-      # creates a new queue to listen to the topic exchange
-      def listen(routing_key="#",&code)
-        queue_name=SecureRandom.hex
-        @queue = @channel.queue(queue_name)
-        @queue.bind(@exchange, :routing_key=>routing_key) # bind queue to the Exchange
-      
-        @queue.subscribe do |headers,payload|
-          # 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.payload.inspect}"
-        @exchange.publish(message.payload,:routing_key => message.route)
-        EM.add_timer(1, Proc.new { close}) if close
-      end
-    
-      def close
-        @connection.close{ EventMachine.stop }
-      
-      end
-    
-    end
-  
-  end
-end

data/lib/runtime/workflow.rb

@@ -1,25 +0,0 @@
-require 'rubygems'
-
-module Factor
-  module Runtime
-    class Workflow
-      attr_accessor :definition
-      attr_reader :name
-    
-      def initialize(definition)
-        @definition=definition
-        @name = @definition["name"]
-      end
-    
-      def get_activity(position)
-        last_position=@definition
-        position.each do |section|
-          return nil if last_position[section].nil?
-          last_position=last_position[section]
-        end
-        last_position
-      end
-    
-    end
-  end
-end

data/lib/runtime/workflow_instance.rb

@@ -1,28 +0,0 @@
-require 'rubygems'
-
-module Factor
-  module Runtime
-    class WorkflowInstance
-      attr_accessor :id, :attributes, :start_message, :workflow
-    
-      def initialize(workflow,attributes)
-        @id=SecureRandom.hex
-        @attributes = attributes
-        @workflow = workflow
-        @start_message = Message.new(@attributes)
-        @start_message.workflow_instance_id=@id
-        @start_message.position=["start"]
-      end
-    
-      def get_activity(position)
-        last_position=@workflow
-        position.each do |section|
-          return nil if last_position[section].nil?
-          last_position=last_position[section]
-        end
-        last_position
-      end
-    
-    end
-  end
-end

data/lib/runtime/workflow_step_messsage.rb

@@ -1,63 +0,0 @@
-require 'rubygems'
-require 'json/ext'
-
-module Factor
-  module Runtime
-    class WorkflowStepMessage
-      attr_accessor :body, :workflow, :workflow_instance_id, :step_id, :last_step_id, :position
-      def initialize
-        @step_id=SecureRandom.hex
-        # @workflow = workflow
-        @body = Hash.new
-        @position = Array.new
-      end
-    
-      def respond(params, event)
-        m = WorkflowStepMessage.new
-        m.body = @body
-        m.workflow_instance_id=@workflow_instance_id
-        m.last_step_id = @step_id
-        m.workflow = @workflow
-        m.position = @position
-        m.position << "on"
-        m.position << event
-        m.add_values(params)
-        m
-      end
-    
-      def add_values(values)
-        current=@body
-        position.each do |key|
-          current[key]={} if !current.include?(key)
-          current=current[key]
-        end
-        values.each do |key,value|
-          current[key]=value
-        end
-      
-      end
-    
-      def route
-        # "#{workflow}.#{position.join('.')}"
-        "workflow"
-      end
-    
-      def payload
-        JSON.generator = JSON::Ext::Generator
-        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 payload
-        message=JSON.parse(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