messed 0.0.1

data/lib/messed/tasks/console.rb

@@ -0,0 +1,70 @@
+class Messed
+  module Tasks
+    class Console
+      
+      module KeyboardHandler
+        include EM::Protocols::LineText2
+
+        attr_accessor :root, :environment
+
+        def log_outgoing(responses)
+          if responses.empty?
+            puts "No responses"
+          else
+            puts "Responding ... #{responses.map{|r| "`#{r.body}'"}.join(', ')}"
+          end
+        end
+
+        def prompt
+          $stdout << ">> "
+          $stdout.flush
+        end
+
+        def post_init
+          print_banner
+          prompt
+        end
+
+        def print_banner
+          puts "?  help"
+          puts "!q quit"
+          puts "Eventhing else is a message"
+        end
+
+        def receive_line(data)
+          case data.strip
+          when '!q'
+            EM.stop_event_loop
+            exit
+          when '?'
+            print_banner
+          else
+            pid = EM.fork_reactor do
+              Booter.new(root, :environment => environment, :supress_banner => true) do |booter|
+                Messed::Logger.instance.setup_logger(::Logger.new(STDOUT), :debug)
+                log_outgoing(booter.application.process(booter.application.message_class.new(data.strip)))
+                EM.stop_event_loop
+              end
+            end
+            Process.wait(pid)
+          end
+          prompt
+        end
+      end
+
+      def self.start
+        new.start
+      end
+      
+      def start
+        EM.run do
+          EM.open_keyboard(KeyboardHandler) do |handler|
+            handler.root = $root
+            handler.environment = ARGV[0]
+          end
+        end
+      end
+  
+    end
+  end
+end

data/lib/messed/tasks/generation.rb

@@ -0,0 +1,12 @@
+class Messed
+  module Tasks
+    class Generation
+      
+      def initialize(name)
+        Dressmaker.new(File.join(File.dirname(__FILE__), '..', '..', '..', 'patterns', 'messed'), File.join(Dir.pwd, name)).generate(:app_name => name)
+      end
+      
+    end
+    
+  end
+end

data/lib/messed/tasks/runner.rb

@@ -0,0 +1,50 @@
+class Messed
+  module Tasks
+    class Runner < Thor
+
+      method_options %w( environment -e ) => "development"
+      method_options %w( detach -d ) => false
+      desc "interface [NAME] [CMD]", "starts an interface (start|stop)"
+      def interface(name, cmd)
+        case cmd
+        when 'start'
+          Messed::Booter.new($root, :detach => options.detach?, :environment => options.environment) do |booter|
+            interface = booter.interface_for(name.to_sym)
+            raise("unable to find an interface with name the `#{name}'") unless interface
+            interface.start
+          end
+        when 'stop'
+          Messed::Booter.new($root, :environment => options.environment).interface_for(name.to_sym).stop
+        end
+      end
+  
+      method_options %w( environment -e ) => "development"
+      method_options %w( detach -d ) => false
+      desc "application [CMD]", "start the application (start|stop)"
+      def application(cmd)
+        case cmd
+        when 'start'
+          Messed::Booter.new($root, :detach => options.detach?, :environment => options.environment) do |booter|
+            application = booter.application
+            application.start
+          end
+        when 'stop'
+          Messed::Booter.new($root, :environment => options.environment).application.stop
+        end
+      end
+      
+      method_options %w( environment -e ) => "development"
+      method_options %w( detach -d ) => false
+      desc "start all interfaces and application [NAME]", "starts all"
+      def all
+        Messed::Booter.new($root, :detach => options.detach?, :environment => options.environment) do |booter|
+          booter.configuration.interfaces.names.each do |name|
+            booter.interface_for(name.to_sym).start
+          end
+          booter.application.start
+        end
+      end
+  
+    end
+  end
+end

data/lib/messed/tasks/status.rb

@@ -0,0 +1,37 @@
+class Messed
+  module Tasks
+    class Status < Thor
+
+      desc "Status", "status"
+      method_options :environment => "development"
+      def status
+        booter = Messed::Booter.new($root, options.environment)
+    
+        puts "=Queues"
+        puts "==Incoming"
+        booter.application.incoming.status.each {|k,v|
+          puts "  %40s - %s" % [k, v]
+        }
+
+        puts "==Outgoing"
+        booter.application.outgoing.status.each {|k,v|
+          puts "  %40s - %s" % [k, v]
+        }
+    
+        puts "=Interfaces"
+        booter.interface_map.each {|name, interface|
+          puts "==#{interface.name}"
+          Messed::Util::RemoteStatus.new(interface.configuration.options['host'], interface.configuration.options['port']).status.each {|k,v|
+            puts "  %40s - %s" % [k, v]
+          }
+        }
+    
+        puts "=Application"
+        Messed::Util::RemoteStatus.new(booter.application.configuration['host'], booter.application.configuration['port']).status.each {|k,v|
+          puts "  %40s - %s" % [k, v]
+        }
+      end
+  
+    end
+  end
+end

data/lib/messed/tasks.rb

@@ -0,0 +1,9 @@
+class Messed
+  module Tasks
+    autoload :Generation, File.join('messed', 'tasks', 'generation')
+    autoload :Runner,     File.join('messed', 'tasks', 'runner')
+    autoload :Status,     File.join('messed', 'tasks', 'status')
+    autoload :Web,        File.join('messed', 'tasks', 'web')
+    autoload :Console,    File.join('messed', 'tasks', 'console')
+  end
+end

data/lib/messed/util/remote_status.rb

@@ -0,0 +1,45 @@
+class Messed
+  module Util
+    class RemoteStatus
+      
+      attr_reader :status
+      
+      class StatusHandler < EM::Connection
+
+        attr_accessor :status
+        
+        def post_init
+          puts "post..."
+          send_data "status\r\n"
+        end
+
+        def receive_data(data)
+          JSON.parse(data).each do |key, value|
+            self.status[key] = status
+          end
+          EM.stop_event_loop
+        end
+      end
+      
+      def initialize(host, port)
+        host ||= '127.0.0.1'
+        @status = {}
+        EM.run do
+          EM.add_timer(5) {
+            @status['error'] = "timeout on connect"
+            EM.stop_event_loop
+          }
+          begin
+            EM.connect(host, port, StatusHandler) do |handler|
+              handler.status = @status
+            end
+          rescue
+            @status['error'] = "can't connect"
+            EM.stop_event_loop
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/messed.rb

@@ -0,0 +1,235 @@
+require 'hashify'
+require 'logger'
+require 'time'
+require 'eventmachine'
+require 'em-http'
+require 'em-beanstalk'
+require 'hwia'
+require 'active_support'
+require 'dressmaker'
+
+$LOAD_PATH << File.dirname(__FILE__)
+
+class Messed
+  
+  autoload :Booter,             File.join('messed', 'booter')
+  autoload :Configuration,      File.join('messed', 'configuration')
+  autoload :Controller,         File.join('messed', 'controller')
+  autoload :EMRunner,           File.join('messed', 'em_runner')
+  autoload :Interface,          File.join('messed', 'interface')
+  autoload :Logger,             File.join('messed', 'logger')
+  autoload :Matcher,            File.join('messed', 'matcher')
+  autoload :Message,            File.join('messed', 'message')
+  autoload :Queue,              File.join('messed', 'queue')
+  autoload :Session,            File.join('messed', 'session')
+  autoload :Tasks,              File.join('messed', 'tasks')
+  autoload :Utils,              File.join('messed', 'utils')
+  
+  module Util
+    autoload :RemoteStatus,     File.join('messed', 'util', 'remote_status')
+  end
+  
+  include Logger::LoggingModule
+  include Controller::Helper
+  include Controller::Processing
+  include Controller::Respond
+
+  after_processing :reset!
+  
+  attr_accessor :controller, :booter, :current_matcher
+  attr_reader   :outgoing, :incoming, :matchers, :session_store, :type, :interface, :name,
+                :messages_received_count, :messages_sent_count, :last_message_received, :last_message_sent
+  
+  def initialize(type = :twitter, &block)
+    @type = type
+    @matchers = []
+    @session_store = Session::Memcache.new
+    @messages_sent_count = 0
+    @messages_received_count = 0
+    
+    @interface = self
+    @name = 'Application'
+    match(&block) if block
+  end
+  
+  def match(&block)
+    instance_eval(&block)
+  end
+  
+  def reset!
+    matchers.clear
+  end
+  
+  def message_class
+    Message.class_for_type(type)
+  end
+  
+  def incoming=(incoming)
+    @incoming = incoming
+    incoming.application = self
+  end
+  
+  def outgoing=(outgoing)
+    @outgoing = outgoing
+    outgoing.application = self
+  end
+  
+  def with(*args, &block)
+    matchers << if args.first.is_a?(Hash)
+      Matcher::Conditional.new(nil, args.first)
+    else
+      Matcher::Conditional.new(*args, &block)
+    end
+    matchers.last.destination = block
+  end
+
+  def otherwise(options = nil, &block)
+    matchers << Matcher::Always.new(&block)
+    matchers.last.destination = block
+  end
+  alias_method :always, :otherwise
+  
+  def status_port
+    booter.configuration.application.status_port || 19191
+  end
+  
+  def status_host
+    booter.configuration.application.status_address || '0.0.0.0'
+  end
+  
+  def start(continue_forever = true)
+    if EM.reactor_running?
+      if booter
+        EM.start_server(status_host, status_port, EMRunner::StatusHandler) do |c|
+          c.interface = self
+        end
+        logger.info "Status handler for #{self.class} started on #{status_host}:#{status_port}"
+        booter.write_pid_file(booter.configuration.application.pid_file)
+      end
+      
+      @connection = EM::Beanstalk.new
+      @connection.watch(incoming.tube) do
+        @connection.use(outgoing.tube) do
+          process_incoming(continue_forever)
+        end
+      end
+    else
+      EM.run {
+        start(continue_forever)
+      }
+    end
+  end
+
+  def stop
+    Process.kill("INT", booter.read_pid_file(booter.configuration.application.pid_file))
+  end
+
+  def process_incoming(continue_forever)
+    @connection.reserve(continue_forever ? nil : 0.5) { |job|
+      begin
+        message = message_class.from_json(job.body)
+        process_responses process(message)
+        job.delete do
+          process_incoming(continue_forever)
+        end
+      rescue JSON::ParserError
+        # unrecoverable
+        logger.error "message #{job.body.inspect} not in JSON format"
+        job.delete do
+          process_incoming(continue_forever)
+        end
+      end
+    }.on_error { |message|
+      EM.stop_event_loop
+    }
+  end
+    
+  def process(message)
+    logger.debug("Processing `#{message.body}'")
+    increment_messages_received!
+    responses = []
+    
+    self.message = message
+    
+    session_store.with(message.unique_id) do |session|
+      self.session = session
+      
+      matchers.find do |matcher|
+        if matcher.match?(message)
+          self.current_matcher = matcher
+          controller = process_destination(matcher.destination)
+          responses.concat(controller.responses)
+          matcher.stop_processing?
+        else
+          false
+        end
+      end
+    
+      controller.reset_processing! if controller.respond_to?(:reset_processing!)
+      reset_processing!
+    end
+    responses
+  end
+
+  def extract_destination(options, block)
+    block ||
+      {:controller => options.delete(:controller) || raise("you must supply a controller"), :action => options.delete(:action) || raise("you must supply an action")} ||
+      raise("you need to either supply options or a block")
+  end
+  protected :extract_destination
+  
+  def reset!
+    self.controller = nil
+    self.message = nil
+    self.params = nil
+    self.session = nil
+  end
+  protected :reset!
+  
+  def process_destination(destination)
+    if destination.respond_to?(:call)
+      instance_eval(&destination)
+      self
+    else
+      class_name = destination[:controller].to_s.split('_').map{|w| w.capitalize}.join
+      self.controller = Kernel.const_get(class_name.to_sym).new
+      self.controller.params = params if controller.respond_to?(:params=)
+      self.controller.message = message if controller.respond_to?(:message=)
+      self.controller.method(destination[:action].to_sym).call
+      self.controller
+    end
+  end
+  protected :process_destination
+
+  def process_responses(responses)
+    if responses && !responses.empty?
+      logger.debug("Putting response #{responses.first.body} onto outgoing queue")
+      @connection.put(responses.shift.to_json) do
+        increment_messages_sent!
+        process_responses(responses)
+      end
+    else
+      logger.debug("No response.")
+    end
+  end
+  
+  def status
+    {
+      :messages_received_count => messages_received_count,
+      :messages_sent_count => messages_sent_count,
+      :last_message_received => last_message_received,
+      :last_message_sent => last_message_sent
+    }
+  end
+  
+  def increment_messages_sent!
+    @messages_sent_count += 1
+    @last_message_sent = Time.new
+  end
+  
+  def increment_messages_received!
+    @messages_received_count += 1
+    @last_message_received = Time.new
+  end
+  
+end

data/patterns/messed/Pattern

@@ -0,0 +1,24 @@
+desc "make executable"
+directory.matches('/bin') do |dir|
+  dir.for('*') { |f|
+    f.append! <<-HERE_DOC
+#!/usr/bin/env ruby
+
+require 'rubygems'
+if ENV['MESSED_HOME']
+  require File.join(ENV['MESSED_HOME'], 'lib', 'messed')
+else  
+  require 'messed'
+end
+
+require 'thor'
+    HERE_DOC
+    
+    f.make_executable!
+  }
+end
+
+desc "set application name to #{options[:app_name]}"
+files.all do |f|
+  f.gsub!('__APP_NAME__', options[:app_name].inspect)
+end

data/patterns/messed/Rakefile

@@ -0,0 +1,12 @@
+require 'spec'
+require 'spec/rake/spectask'
+task :spec => 'spec:all'
+namespace(:spec) do
+  Spec::Rake::SpecTask.new(:all) do |t|
+    t.spec_opts ||= []
+    t.spec_opts << "-rubygems"
+    t.spec_opts << "--options" << "spec/spec.opts"
+    t.spec_files = FileList['spec/**/*_spec.rb']
+  end
+
+end

data/patterns/messed/app/runner.rb

@@ -0,0 +1,5 @@
+# define your mappings here
+
+#with 'hey you' do
+#  say 'hey hey'
+#end

data/patterns/messed/bin/console

@@ -0,0 +1,3 @@
+$root = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+Messed::Tasks::Console.start

data/patterns/messed/bin/runner

@@ -0,0 +1,3 @@
+$root = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+Messed::Tasks::Runner.start

data/patterns/messed/bin/status

@@ -0,0 +1,3 @@
+$root = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+Messed::Tasks::Status.start

data/patterns/messed/bin/web

@@ -0,0 +1,13 @@
+class WebTask < Thor
+
+  method_options :detach => false
+  method_options :environment => "development"
+  def start
+    
+    
+    
+  end
+  
+end
+
+IncomingRunnerTask.start

data/patterns/messed/config/environment.rb

@@ -0,0 +1,15 @@
+queues.incoming.host = '127.0.0.1'
+queues.incoming.port = 11300
+queues.incoming.tube = 'incoming-tube'
+
+queues.outgoing.host = '127.0.0.1'
+queues.outgoing.port = 11300
+queues.outgoing.tube = 'outgoing-tube'
+
+# interfaces.search.adapter = :twitter_search
+# interfaces.search.options[:fetch] = {:query => {'q' => 'love'}, :host => 'search.twitter.com', :path => 'search.json'}
+# interfaces.search.options[:interval] = 30
+
+# interfaces.twitter_sender.adapter = :twitter_sender
+# interfaces.twitter_sender.options[:username] = 'username'
+# interfaces.twitter_sender.options[:password] = 'password'

data/patterns/messed/config/environments/development.rb

@@ -0,0 +1,2 @@
+self.logger = ::Logger.new(STDOUT)
+self.log_level = :debug

data/patterns/messed/spec/application_spec.rb

@@ -0,0 +1,12 @@
+require 'spec/spec_helper'
+
+describe "test" do
+  
+  include MessedSpecHelper
+  
+  it "should have a test" do
+    process('this is my message')
+    outgoing_messages.size.should == 1
+    outgoing_messages.first.body.should == "well, that was fun"
+  end
+end

data/patterns/messed/spec/spec.opts

@@ -0,0 +1,7 @@
+--colour
+--format
+specdoc
+--loadby
+mtime
+--reverse
+--backtrace

data/patterns/messed/spec/spec_helper.rb

@@ -0,0 +1,44 @@
+require 'rubygems'
+begin
+  require 'messed'
+rescue LoadError
+  if ENV['MESSED_HOME']
+    require File.join(ENV['MESSED_HOME'], 'lib', 'messed')
+  else  
+    raise("no messed!")
+  end
+end
+
+class MessedSpecHolder
+  
+  attr_accessor :booter, :outgoing_messages
+  
+  def initialize
+    @booter = Messed::Booter.new(File.join(File.dirname(__FILE__), '..'))
+  end
+  
+  def application
+    @booter.application
+  end
+  
+  def process(message)
+    @outgoing_messages = application.process(application.message_class.new(message))
+  end
+  
+end
+
+
+
+module MessedSpecHelper
+
+  Holder = MessedSpecHolder.new
+
+  def process(message)
+    Holder.process(message)
+  end
+
+  def outgoing_messages
+    Holder.outgoing_messages
+  end
+  
+end

data/spec/adapter/applications/twitter_search/app/application.rb

@@ -0,0 +1,3 @@
+with 'hey you' do
+  say 'hey hey'
+end

data/spec/adapter/applications/twitter_search/app/runner.rb

@@ -0,0 +1,7 @@
+with 'hey you' do
+  say 'hey hey'
+end
+
+otherwise do
+  say message
+end