evegem 0.1.2

data/.gitignore

@@ -0,0 +1,14 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+config/database.yml
+.DS_Store
+.rvmrc
+log
+doc
+appstats_*
+*_real_spec.rb
+*.rdb
+*.log
+*.cmd

data/Gemfile

@@ -0,0 +1,5 @@
+source "http://gems.cenx.test"
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in eve.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+import 'lib/eve/ci.rake'
+RSpec::Core::RakeTask.new

data/autotest/discover.rb

@@ -0,0 +1,2 @@
+require 'autotest/fsevent'
+Autotest.add_discovery { "rspec2" }

data/bin/eve

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require "bundler/setup"
+require File.dirname(__FILE__) + "/../lib/evegem"
+
+case ARGV.first
+  when "server"
+    ARGV.shift
+    Eve::EventConnection.run(ARGV)
+  when "watch"
+    ARGV.shift
+    Signal.trap("SIGINT") { exit }
+    Eve::FileNotifierConnection.run(ARGV)
+  else
+    app = Eve::Application.new(:display => :stdio, :system_calls_display => { :filename => "./eve_system_calls.log" })
+    Signal.trap("SIGINT") { app.enqueue_cmd("exit") }
+    app.run(ARGV)
+end

data/config.ru

@@ -0,0 +1,2 @@
+require File.dirname(__FILE__) + '/lib/evegem'
+run Eve::WebServer.new

data/config/database.yml.example

@@ -0,0 +1,16 @@
+development:
+  adapter: mysql2
+  encoding: utf8
+  reconnect: true
+  database: eve_dev
+  pool: 5
+  username: root
+  socket: "/tmp/mysql.sock"
+test:
+  adapter: mysql2
+  encoding: utf8
+  reconnect: true
+  database: eve_dev
+  pool: 5
+  username: root
+  socket: "/tmp/mysql.sock"

data/config/reset_db.rb

@@ -0,0 +1,10 @@
+
+require "#{File.dirname(__FILE__)}/../spec/db_helper"
+
+env = Object.const_defined?('Rails') ? Rails.env : "test"
+db = YAML::load(File.open("#{File.dirname(__FILE__)}/database.yml"))[env]
+
+path = ENV['SIN_DOC_PATH'] || "#{File.dirname(__FILE__)}/../../sin_doc"
+execute_sql(db,"drop database `#{db['database']}`;",false)
+execute_sql(db,"create database `#{db['database']}`;",false)
+execute_sql_file(db,"#{path}/CDB_EXPORT_For_Test_Suite.sql",true)

data/eve.gemspec

@@ -0,0 +1,39 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "eve/version"
+
+Gem::Specification.new do |s|
+  s.name        = "evegem"
+  s.version     = Eve::VERSION
+  s.authors     = ["Andrew Forward"]
+  s.email       = ["andrew.forward@cenx.com"]
+  s.homepage    = ""
+  s.summary     = %q{A DSL for managing OSS Data Entry}
+  s.description = %q{A DSL for managing OSS Data Entry}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.executables   = [ 'eve' ]
+  s.require_paths = ["lib"]
+
+  s.add_dependency('utest','>=0.0.3')
+  s.add_dependency('watchme','>=0.0.1')
+  s.add_dependency('awesome_print')
+  s.add_dependency('rake','0.9.2')
+  s.add_dependency('rails','>=3.2.1')
+  s.add_dependency('mysql2','0.3.11')
+  s.add_dependency('rack','1.4.1')
+  s.add_dependency('eventmachine','0.12.10')
+  s.add_dependency('net-ssh','2.3.0')
+  s.add_dependency('redis','2.2.0')
+
+  s.add_development_dependency('rspec')
+  s.add_development_dependency('autotest')
+  s.add_development_dependency('autotest-fsevent') if RUBY_PLATFORM =~ /darwin/i
+  s.add_development_dependency('ZenTest')
+  s.add_development_dependency('rb-fsevent') if RUBY_PLATFORM =~ /darwin/i
+  s.add_development_dependency('geminabox')
+  s.add_development_dependency('simplecov')
+  
+end

data/lib/eve/application.rb

@@ -0,0 +1,465 @@
+module Eve
+  
+  class Application
+    
+    cattr_accessor :cmd_data
+    attr_accessor :id, :console, :system_calls, :message, :redis, :poll, :poll_cmds, :cmds, :big_t, :mode, :server, :port
+    
+    @@cmd_data = {
+      "version" => [],
+      "help" => [],
+      "appid" => [],
+      "shell" => [],
+      "poll" => [ "set", "add", "rm" ],
+      "event" => [],
+      "remote" => [],
+      "interrupt" => [],
+      "register" => [ "add", "rm", "reload", "add-path", "rm-path", "path" ],
+      "print" => [],
+      "exit" => [],
+    }
+
+    def initialize(data = {})
+      @redis = data[:redis] || Redis.new
+      @console = Messenger.new( :display => data[:display] )
+      @system_calls = Messenger.new( :display => data[:system_calls_display] || data[:display] )
+      
+      @message = Message.new(self)
+      @poll = 5*60
+      @poll_cmds = []
+      @cmds = []
+      @big_t = data[:big_t] || "1month"
+      @mode = data[:mode] || :queue
+      @server = data[:server] || "0.0.0.0"
+      @port = data[:port] || "4848"
+      @running = false
+    end
+    
+    def reset
+      @cmds = []
+      @console.reset
+    end
+
+    def self.extract_arg(name,args,default = [],has_data = true)
+      is_multi = default.kind_of?(Array)
+      index = args.index(name)
+      return default if index.nil?
+      return is_multi ? [true] : true unless has_data
+      
+      results = []
+      args.each_with_index.collect { |d,i| d == name ? i : nil }.compact.each do |index|
+        val = ""
+        args[index+1..-1].each do |data|
+          break if data.start_with?("--")
+          val += " #{data}"
+        end
+        results << val.strip
+      end
+      is_multi ? results : results.first
+    end
+    
+    def self.methodize(input)
+      input.gsub(/-/,"_")
+    end
+
+    def default_result
+      { :data => nil, :status => :continue, :track_cmd => true }
+    end
+
+    #------------
+    # EVENT MACHINE
+    #------------
+
+    def post_init
+      @message.print_server_init
+    end
+    
+    def receive_data(data)
+      cmd(data,true,true)
+    end
+    
+    #------------
+    # MAIN DRIVER - RUN / CMD
+    #------------
+
+    def run(args = [])
+      @running = true
+      scripts = ["version"] + handle_args(args)
+      loop do
+        scripts.each do |script|
+          status = cmd(script,true,true)[:status]
+          status = cmd("exit") if status == :should_exit
+          return if status == :exited
+        end
+        scripts = next_cmds
+      end
+    end  
+    
+    def call_interrupt(result,appid,display_messages)
+      @redis.set(lookup_id("mode",appid),"shell")
+      @message.print_app_interrupted(appid) if display_messages
+      result
+    end
+    
+    def cmd(raw,display_messages = true,external_cmd = false)
+      result = default_result
+      raw = "remote #{raw}" if @mode == :event
+      begin
+        action, data = action_and_input(raw)
+      
+        num_times_processed = 0
+        if @@cmd_data.keys.include?(action)
+          inner_action, inner_data = action_and_input(data)
+          if @@cmd_data[action].include?(inner_action)
+            result = send(Application.methodize("call_#{action}_#{inner_action}"), result, inner_data, display_messages)  
+          else
+            result = send(Application.methodize("call_#{action}"), result, data, display_messages)  
+          end
+          num_times_processed += 1
+        end
+        num_times_processed, result = delegate(num_times_processed,result,raw,display_messages) unless @id.nil?
+        
+        if num_times_processed == 0 && !action.empty?
+          @message.print_unknown_cmd(raw)
+        end
+        
+        @cmds << raw if external_cmd && result[:track_cmd]
+      rescue Exception => ex
+        @message.print_cmd_error(raw,ex)
+      end
+      result
+    end
+    
+    #------------
+    # CALLER METHODS
+    #------------ 
+    
+    def call_register(result,data,display_messages)
+      result[:data] = {}
+      @redis.smembers(lookup_id("registers")).collect do |classname|
+        result[:data][classname] = @redis.smembers(lookup_id("register.#{classname}.files"))
+      end
+      @message.print_registry(result[:data])
+      result
+    end
+    
+    def call_register_add(result,data,display_messages)
+      parts = data.split
+      classname = parts[0]
+      filename = parts[1]
+      if filename.nil? || filename == ""
+        (cmd("register path",false)[:data]).each do |path|
+          filename = "#{path}/#{classname.split("::").last.underscore}.rb"
+          next unless p?(filename)
+          filename = p(filename)
+          break
+        end
+      end
+      load filename  
+      @redis.sadd(lookup_id("registers"),classname)
+      @redis.sadd(lookup_id("register.#{classname}.files"),filename)
+      result[:data] = true
+      result
+    end
+
+    def call_register_add_path(result,path,display_messages)
+      if p?(path)
+        result[:data] = @redis.sadd(lookup_id("register.paths"),p(path))
+      else
+        result[:data] = false
+      end
+      result
+    end
+
+    def call_register_rm_path(result,path,display_messages)
+      normalized_path = p?(path) ? p(path) : path
+      result[:data] = @redis.srem(lookup_id("register.paths"),normalized_path)
+      result
+    end
+
+    def call_register_path(result,path,display_messages)
+      result[:data] = [ p("#{File.dirname(__FILE__)}/../registry") ] + @redis.smembers(lookup_id("register.paths"))
+      @message.print_registry_path(result[:data]) if display_messages
+      result
+    end
+
+    def call_register_rm(result,classname,display_messages)
+      result[:data] = @redis.srem(lookup_id("registers"),classname)
+      @redis.del(lookup_id("register.#{classname}.files"))
+      result
+    end
+    
+    def call_register_reload(result,data,display_messages)
+      @redis.smembers(lookup_id("registers")).each do |classname|
+        @redis.smembers(lookup_id("register.#{classname}.files")).each do |filename|
+          load filename
+        end
+      end
+      @message.print_registry_reloaded if display_messages
+      result[:data] = true
+      result
+    end
+    
+    def call_appid(result,appid,display_messages)
+      @id = appid == "" || appid.nil? ? $$.to_s : appid
+      
+      is_existing = @redis.sismember("Eve.ApplicationIds",@id)
+      @redis.sadd("Eve.ApplicationIds",@id)
+      result[:data] = @id
+      @message.print_appid(@id)
+      cmd("register reload",display_messages) if is_existing
+      result
+    end
+    
+    def call_version(result,data,display_messages)
+      result[:data] = Eve::VERSION
+      @message.print_version(@id) if display_messages
+      result
+    end
+    
+    def call_help(result,data,display_messages)
+
+      if data.nil? || data == ""
+        result[:data] = @@cmd_data.dup
+        @redis.smembers(lookup_id("registers")).each do |name|
+          clazz = reg(name)
+          if clazz.nil?
+            @redis.srem(lookup_id("registers"),name)
+          else
+            result[:data].merge!(clazz.available)
+          end
+        end
+      else
+        clazz = reg(data)
+        if clazz.nil?
+          @message.print_unknown_handler(data) if display_messages
+          result[:data] = {}
+        else
+          result[:data] = clazz.available  
+        end
+      end
+      @message.print_help(result[:data],data) if display_messages && !result[:data].empty?
+      result
+    end
+    
+    def call_print(result,msg,display_messages)
+      result[:data] = msg
+      @console.print("#{msg}\n") if display_messages
+      result
+    end
+
+    def call_exit(result,data,display_messages)
+      result[:status] = :exited
+      @message.print_exit if display_messages
+      result
+    end
+
+    def call_poll(result,duration,display_messages)
+      result[:data] = @poll_cmds
+      @message.print_poll_details(@poll,result[:data])
+      result
+    end
+
+    def call_poll_add(result,cmd,display_messages)
+      @poll_cmds << cmd
+      result
+    end
+
+    def call_poll_rm(result,index,display_messages)
+      result[:data] = []
+      if index.to_i.to_s == index
+        @poll_cmds.delete_at(index.to_i)
+      else
+        @poll_cmds.delete(index)
+      end
+      result
+    end
+    
+    def call_poll_set(result,duration,display_messages)
+      @mode = :poll
+      in_secs = WatchMe::Timer.to_seconds(duration)
+      result[:data] = in_secs
+      @poll = in_secs
+      @message.print_poll_mode(@id,in_secs) if display_messages
+      result
+    end
+    
+    def call_shell(result,data,display_messages)
+      @mode = :shell
+      result[:data] = @mode
+      @message.print_shell_mode if display_messages
+      result
+    end
+    
+    def call_event(result, data, display_messages)
+      @mode = :event
+      @server,@port = data.split(":")
+      @server ||= "0.0.0.0"
+      @port ||= "4848"
+      result[:data] = { :server => @server, :port => @port }
+      @message.print_event_mode("#{@server}:#{@port}") if display_messages
+      result
+    end
+    
+    def call_remote(result, cmd, display_messages)
+      should_exit = false
+      begin
+        @telnet ||= Net::Telnet::new("Host" => @server, "Port" => @port, "Timeout" => 10, "Telnetmode" => false) # debugging "Output_log"=>"application_telnet.log"
+        if cmd == "exit"
+          should_exit = true
+          @telnet.close
+        else
+          result[:data] = @telnet.cmd(cmd) do |data|
+            data.sub!(/[^\n]*> $/,"") unless @running
+            @console.print data  
+          end
+        end
+      rescue Exception => ex
+        @message.print_error("Telnet session failed", ex)
+        should_exit = true
+      end
+      
+      if should_exit
+        @mode = :shell
+        cmd("exit",display_messages)
+        result[:status] = :exited
+      end
+      
+      result
+    end
+
+    #------------
+    # HELPER METHODS
+    #------------    
+
+    def reg(classname)
+      begin
+        all_names = classname.split("::")
+        all_names.size == 1 ? Object::const_get(classname) : eval(all_names[0...-1].join("::")).const_get(all_names.last)
+      rescue
+        nil
+      end
+    end
+
+    def delegate(num_times_processed,result,cmd,display_messages)
+      all_results = num_times_processed > 0 ? [ result.dup ] : []
+      @redis.smembers(lookup_id("registers")).each do |classname|
+        all_names = classname.split("::")
+        clazz = reg(classname)
+        next unless clazz.handle?(cmd)
+        all_results << clazz.handle(self,cmd,display_messages)
+        num_times_processed += 1
+      end
+      result[:data] = nil if num_times_processed == 0
+      result[:data] = all_results[0][:data] if num_times_processed == 1
+      result[:data] = all_results if num_times_processed > 1
+      [ num_times_processed, result ]
+    end
+    
+    def enqueue_cmd(raw)
+      @redis.rpush(lookup_id("next_cmds"),raw)
+    end
+    
+    def next_cmds(scripts = [])
+      case(@mode)
+        when :event
+          scripts << user_input
+        when :poll
+          scripts += @poll_cmds
+          scripts << "sleep #{@poll}"
+        when :shell
+          scripts << user_input
+        when :queue
+          the_cmd = @redis.lpop(lookup_id("next_cmds")) || "exit"
+          scripts << the_cmd
+      end
+      scripts
+    end
+
+    def handle_args(args)
+      scripts = []
+      
+      is_event = false
+      Application.extract_arg("--event",args).each do |event|
+        is_event = true
+        scripts << "event #{event}"
+      end
+
+      index = args.index("--interrupt")
+      unless index.nil?
+        scripts << "interrupt #{args[index+1]}"
+        scripts << "exit"
+        return scripts
+      end
+
+      index = args.index("--id")
+      if !index.nil?
+        scripts << "appid #{args[index + 1]}"
+      elsif @id.nil? && !is_event
+        scripts << "appid"
+      end
+      
+      Application.extract_arg("--register",args).each { |register| scripts << "register add #{register}" }
+
+      unless is_event
+        Application.extract_arg("--poll",args).each { |poll| scripts << "poll #{poll}" }
+        scripts << "shell" unless Application.extract_arg("--shell",args,nil,false).nil?
+      end
+
+      Application.extract_arg("--run",args).each do |cmd|
+        scripts << cmd
+      end
+
+      scripts
+    end
+    
+    def self.ids(redis = Redis.new)
+      redis.smembers("Eve.ApplicationIds")
+    end
+    
+    def self.alive?(id)
+      return false if id == "" || id.nil?
+      begin
+        Process.kill 0, id.to_i
+        true
+      rescue Exception => ex
+        false
+      end
+    end
+    
+    def lookup_id(sub_id, appid = nil)
+      raise "Application ID not set yet" if appid.nil? && @id.nil?
+      appid ||= @id
+      "Eve.#{appid}.#{sub_id}"
+    end
+    
+    def history
+      @console.history
+    end
+    
+    def system_call(input)
+      @message.print_system_call(input)
+      `#{input}`
+    end
+    
+    def user_input
+      @console.print "> " unless @mode == :event
+      STDOUT.flush
+      STDIN.gets.chomp
+    end
+
+
+    private
+      
+      def action_and_input(raw)
+        return [ "", nil ] if raw.nil?
+        action = raw.split.shift
+        return [ "", nil ] if (action.nil? || action.starts_with?("#"))
+        data = raw[(action.size)..-1].strip
+        [ action, data ]
+      end
+      
+    
+  end
+  
+end