factor 0.0.3 → 0.0.4

data/bin/factor

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
+require "rubygems"
+require "factor"
 
-require 'factor'
-
-Factor::Agent.hi(ARGV[0])
+Factor::CLI::FactorTask.start

data/lib/channel/activity.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+
+module Factor  
+  module Channel
+    class Activity
+      def do_work(params)
+      end
+    end
+  end
+end

data/lib/channel/channel.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+
+module Factor
+  module Channel
+    class Channel
+    end
+  end
+end

data/lib/channel/event.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+
+module Factor
+  module Channel
+    class Event
+      attr_accessor :params
+    
+      def initialize
+        @params = Hash.new
+      end
+    end
+  end
+end

data/lib/channel/trigger.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+
+module Factor
+  module Channel
+    class Trigger
+      def start(params)
+    
+      end
+    
+      def end
+      
+      end
+    end
+  
+  end
+end

data/lib/cli/channel_task.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'cli/command'
+
+module Factor
+  module CLI
+    class ChannelTask < Command
+  
+      desc "install NAME", "install a new channel"
+      def install(name)
+      end
+  
+      desc "uninstall NAME", "uninstall the channel"
+      def uninstall(name)
+      end
+  
+      desc "list", "list all my installed channels"
+      def list
+      end
+  
+      desc "all", "list all channels available for installation"
+      def all
+      end
+    end
+  end
+end

data/lib/cli/command.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'thor'
+require 'thor/group'
+require 'yaml'
+require 'rest_client'
+
+
+module Factor
+  module CLI
+    class Command < Thor
+      CONFIG_FILE_DIR = File.expand_path("~/.factor") 
+      no_tasks do
+        def save_config(config)
+          File.open(CONFIG_FILE_DIR,'w') do |file|
+            YAML::dump(config,file)
+          end
+        end
+    
+        def get_config
+          File.exists?(CONFIG_FILE_DIR) ? YAML::load_file(CONFIG_FILE_DIR) : {}
+        end
+      end
+    end
+  end
+end

data/lib/cli/credential_task.rb

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'cli/command'
+
+module Factor
+  module CLI
+    class CredentialTask < Command
+    
+      desc "list", "list all the credentials"
+      def list
+      end
+    
+      desc "add KEY VALUE", "add a key and value for the credential"
+      def add
+      end
+    
+      desc "remove KEY", "remove a value from the credentials bag"
+      def remove
+      end
+    
+    end
+  end
+end

data/lib/cli/factor_task.rb

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'cli/command'
+require 'cli/server_task'
+require 'cli/workflow_task'
+require 'cli/credential_task'
+
+module Factor
+  module CLI
+    class FactorTask < Command
+  
+      desc "register","register a new account"
+      method_option :email, :alias=>"-e", :type=>:string, :desc=>"Email address you would like to use for new account"
+      method_option :password, :alias=>"-p", :type=>:string, :desc=>"Password you would like to use for new account"
+      def register
+        email = options[:email]==nil ? ask("Email address:") : options[:email]
+        password = options[:password]==nil ? ask("Password:") : options[:password]
+    
+        # register with email/password
+    
+      end
+  
+      desc "login", "login to the account"
+      method_option :email, :alias=>"-u", :type=>:string, :desc=>"Account email address"
+      method_option :password, :alias=>"-p", :type=>:string, :desc=>"Account password"
+      def login
+        email = options[:email]==nil ? ask("Email address:") : options[:email]
+        password = options[:password]==nil ? ask("Password:") : options[:password]
+    
+        #login with email/password
+      end
+  
+      desc "token", "login with token"
+      method_option :token, :alias=>"-t", :type=>:string, :desc=>"Token value to set", :required=>true
+      def token
+        config = get_config
+        config[:token]=options[: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")

data/lib/cli/server_task.rb

@@ -0,0 +1,47 @@
+require 'rubygems'
+require 'cli/command'
+
+module Factor
+  module CLI
+    class ServerTask < Command
+      desc "start", "start the server"
+      def start
+        engine = Factor::Engine.new
+
+        client = Factor::Client.new
+        client.login_token(get_config[:token])
+      
+        puts "loading channels"
+        engine = client.load_channels(engine)
+        puts "loading channels complete"
+      
+        puts "loading workflows"
+        engine = client.load_workflows(engine)
+        puts "loading workflows complete"
+    
+        puts "loading credentials"
+        engine = client.load_credentials(engine)
+        puts "loading credentials complete"
+    
+        puts "starting the server..."
+        engine.start
+    
+      end
+  
+      desc "list", "list all the running servers"
+      def list
+        puts "listing all servers"
+      end
+  
+      desc "logs", "listen to incoming logs"
+      def logs
+        engine = Factor::Engine.new
+        puts "Listening..."
+        engine.logs do |message|
+          puts "[#{message.route}] #{message.body}"
+        end
+      end
+  
+    end
+  end
+end

data/lib/cli/workflow_task.rb

@@ -0,0 +1,26 @@
+require 'rubygems'
+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::Engine.new
+        id = engine.launch(workflow_name,options.parameters)
+    
+        puts "workflow executed with id #{id}"
+      end
+  
+      desc "list", "list all available workflows"
+      def list
+      
+      
+      end
+    end
+  end
+end

data/lib/client/client.rb

@@ -0,0 +1,118 @@
+require 'rubygems'
+require 'rest_client'
+require 'zip'
+require 'zip/zipfilesystem'
+require 'open-uri'
+
+module Factor
+  module Client
+    class Client
+      HOST = "http://localhost:3000"
+    
+      def register(email,password)
+      end
+    
+      def login(email, password)
+      end
+    
+      def login_token(token)
+        @token=token
+      end
+    
+      def load_workflows(engine)
+        workflows = rest_get("workflows")
+        workflows.each do |workflow|
+          workflow_definition = JSON.parse(workflow['definition'])
+          workflow=Factor::Workflow.new(workflow_definition)
+          engine.load_workflow(workflow)
+        end
+        engine
+      end
+    
+      def load_credentials(engine)
+      
+        credentials_definition = rest_get("credentials")
+        credentials = JSON.parse(credentials_definition["bag"])
+        engine.load_credentials(credentials)
+      
+        engine
+      end
+    
+    
+      def load_channels(engine)
+      
+        # get list of channels
+        channels = rest_get("channels")
+      
+        #load each channel
+        channels.each do |channel|
+        
+          # 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.to_s.gsub(/\W+/,'-'), '.zip'], :encoding => 'ascii-8bit')
+        
+          # 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
+        
+          # unzip download zip into unzipped directory
+          unzip(temp_file.path,unzip_dir)
+        
+          Dir.glob("#{unzip_dir}/#{channel['name'].downcase}/*.rb").each do |file|
+            engine.load_channel(file)
+          end
+        
+        end
+      
+      
+        engine
+      end
+    
+    
+      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 rest_get(path)
+        JSON.parse(RestClient.get "#{HOST}/#{path}.json?auth_token=#{@token}")
+      end
+    
+    end
+  end
+end

data/lib/factor.rb

@@ -1,9 +1,7 @@
-$LOAD_PATH.unshift File.dirname(__FILE__)
 require 'rubygems'
-require 'SecureRandom'
-require "amqp"
-require 'json'
-require 'activity.rb'
-require 'worker.rb'
-require 'engine.rb'
-require 'message.rb'
+
+# load all the libraries
+lib_files = "../**/*.rb"
+Dir[File.expand_path(lib_files,__FILE__)].each do |file|
+  require file
+end

data/lib/runtime/attributes.rb

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

@@ -0,0 +1,107 @@
+require 'rubygems'
+require 'factor'
+require 'mustache'
+
+
+module Factor
+  module Runtime
+    class Engine
+      attr_accessor :channel_modules, :workflows, :message_bus
+    
+      # Engine needs modules that contain the code, workflows to run, and message bus for communication
+      def initialize
+        @channel_modules=Hash.new
+        @workflows = Hash.new
+        @message_bus ||= MessageBus.new
+        @credentials = Hash.new
+      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
+        file=File.new filename
+        require file
+        channel_module_name = File.basename(file).gsub('.rb','').split('_').map{|ea| ea.capitalize}.join('')
+        channel_module= self.class.const_get(channel_module_name)
+      
+        @channel_modules[channel_module.definition["module"]]=channel_module  
+      end
+    
+      def load_credentials credentials
+        @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 launch workflow, params
+        instance_id=SecureRandom.hex
+        @message_bus.start do
+          message = Message.new
+          message.position << "start"
+          message.workflow=workflow
+          message.add_values params
+          message.workflow_instance_id= instance_id
+          @message_bus.send_and_close message
+        end
+        instance_id
+      end
+    
+      # start your engines. vroom vrooooom!
+      def start
+        @message_bus.start do
+          @message_bus.listen do |message|
+            if @workflows.include? message.workflow
+              workflow = @workflows[message.workflow]
+              activity = workflow.get_activity(message.position)
+              if !activity.nil?
+                # puts "[activity] #{activity.to_s}"
+                action = activity["action"]
+                channel = activity["channel"]
+                method = activity["method"]
+              
+                values = message.body.merge(@credentials)
+                puts "[values] #{values}"
+                # this maps the input values passed in with the templated defined in the workflow
+                params = Hash.new
+                activity["params"].each do |key,template|
+                  params[key]=Mustache.render(template,values)
+                end
+                puts "[calling] #{channel}::#{method} (#{params.to_s})"
+                event = call_channel_method(channel,method,params)
+              
+                response_message = message.respond(event.params,event.class.name.split("::").last)
+              
+              
+                @message_bus.send response_message
+              
+              end
+            else
+              # workflow doesn't exist
+            end
+          end
+        end
+      end
+
+
+      def call_channel_method(channel_name,class_name,params)
+        channel_module = @channel_modules[channel_name]
+        command = channel_module.const_get(class_name)
+        command.new.do_work(params)
+      end
+    end
+  end
+end

data/lib/runtime/message.rb

@@ -0,0 +1,65 @@
+require 'rubygems'
+require 'SecureRandom'
+require 'json'
+
+module Factor
+  module Runtime
+    class Message
+      attr_accessor :body, :workflow, :workflow_instance_id, :activity_instance_id, :last_activity_instance_id, :position
+      def initialize
+        @activity_instance_id=SecureRandom.hex
+        @workflow = workflow
+        @body = Hash.new
+        @position = Array.new
+      end
+    
+      def respond(params, event)
+        m = Message.new
+        m.body = @body
+        m.workflow_instance_id=@workflow_instance_id
+        m.last_activity_instance_id = @activity_instance_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|
+          #puts "[add value] #{key} (#{key.class.name})"
+          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('.')}"
+      end
+    
+      def payload
+        {"body"=>@body, "workflow_instance_id"=>@workflow_instance_id, "activity_instance_id"=>@activity_instance_id, "last_activity_instance_id"=>@last_activity_instance_id}.to_json
+      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
+      
+        message=JSON.parse(payload)
+        @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"]
+      end
+    
+    end
+  end
+end

data/lib/runtime/message_bus.rb

@@ -0,0 +1,57 @@
+require 'rubygems'
+require 'SecureRandom'
+
+module Factor
+  module Runtime
+    class MessageBus
+      attr_accessor :host, :connection, :channel, :exchange, :queue
+    
+      def initialize(host="queue.factor.io")
+        @host = host
+      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="workflow",&code)
+        EventMachine.run do
+          @connection = AMQP.connect(:host=>@host)
+          @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|
+          message = Message.new
+          message.from_queue headers.routing_key, payload
+          code.call(message)
+        end
+      end
+    
+      def send(message)
+        @exchange.publish(message.payload,:routing_key => message.route)
+      end
+    
+      def send_and_close(message)
+        send(message)
+      
+        EM.add_timer(1, Proc.new { close})
+      
+      end
+    
+      def close
+        @connection.close{ EventMachine.stop }
+      
+      end
+    
+    end
+  
+  end
+end

data/lib/runtime/workflow.rb

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

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: factor
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,16 +9,33 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-15 00:00:00.000000000 Z
+date: 2012-12-09 00:00:00.000000000 Z
 dependencies: []
-description: Library to create Channels for Factor
+description: Friendly command-line interface and library for Factor
 email: maciej@skierkowski.com
 executables:
 - factor
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/channel/activity.rb
+- lib/channel/channel.rb
+- lib/channel/event.rb
+- lib/channel/trigger.rb
+- lib/cli/channel_task.rb
+- 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/message.rb
+- lib/runtime/message_bus.rb
+- lib/runtime/workflow.rb
+- lib/runtime/workflow_instance.rb
 - bin/factor
 homepage: http://rubygems.org/gems/factor
 licenses: []
@@ -26,6 +43,7 @@ post_install_message:
 rdoc_options: []
 require_paths:
 - lib
+- lib
 required_ruby_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -43,5 +61,5 @@ rubyforge_project:
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: Factor.io Library
+summary: Factor.io Library and CLI
 test_files: []