evegem 0.1.2

data/lib/eve/ci.rake

@@ -0,0 +1,68 @@
+namespace :ci do
+
+  desc "Build the project"
+  task :build do
+    begin
+      # Rake::Task['ci:db:config'].invoke
+      Rake::Task['ci:local'].invoke
+      Rake::Task['ci:success'].invoke
+    rescue Exception => e
+      Rake::Task['ci:failure'].invoke
+      raise e
+    end
+  end
+  
+  desc "Run CI from your local machine (will not propagte the success / failure message, or load the config file)"
+  task :local do
+    Rake::Task['ci:db:reset'].invoke
+    Rake::Task['ci:rspec'].invoke
+  end
+
+  desc 'Run Rspec'
+  task :rspec do
+    system 'mkdir -p ../public' unless File.exists?("../public")
+    Rake::Task['ci:rspec_run'].invoke
+  end
+
+  RSpec::Core::RakeTask.new(:rspec_run) do |t|
+    t.rspec_opts = ["--format", "html", "--out", "../public/rspec.html"]
+    t.fail_on_error = true
+  end
+  
+  desc "The Build Succeeded, so tell our monitoring service"
+  task :success do
+    if File.exists?("/home/deployer/monitor/log")
+      system 'echo "Eve succeeded, http://cc.cenx.localnet" > /home/deployer/monitor/log/Eve.cc'
+    else
+      print "BUILD SUCCEEDED, but log directory (/home/deployer/monitor/log) does not exist"
+    end
+  end
+
+  desc "The Build failed, so tell our monitoring service"
+  task :failure do
+    if File.exists?("/home/deployer/monitor/log")
+      system "curl http://cc.cenx.localnet/eve > /home/deployer/monitor/log/Eve.cc"
+    else
+      raise "BUILD FAILED, but log directory (/home/deployer/monitor/log) does not exist"
+    end
+  end
+  
+  namespace :db do
+
+    desc "Setup the correct database configuration files"
+    task :config do
+      copy_config('database','/cenx/eve/sensitive/database.yml',"#{File.dirname(__FILE__)}/../../config/database.yml")
+    end
+    
+    desc "Setup the database"
+    task :reset do
+      system("ruby #{File.dirname(__FILE__)}/../../config/reset_db.rb")
+    end
+    
+    def copy_config(type,source,dest)
+      abort "No #{type} file [#{source}], unable to continue CI build" unless File.exists? source
+      FileUtils.cp source, dest, :preserve => false
+    end
+    
+  end
+end

data/lib/eve/event_server.rb

@@ -0,0 +1,67 @@
+
+module Eve
+
+  class EventConnection < EM::Connection
+    
+    cattr_accessor :data
+    attr_accessor :app, :server
+    
+    def self.run(args)
+      server,port,appid = EventServer.handle_args(args).values
+      @@data = { :appid => appid }
+      
+      EM.run do
+        EM.start_server(server, port, EventConnection)
+        puts "Started Eve (#{appid}) on #{server}:#{port}..."
+      end      
+    end
+
+    def post_init
+      @server = EventServer.new(self,@@data)
+      @server.post_init
+    end
+    
+    def receive_data(data)
+      @server.receive_data(data)
+    end
+    
+  end
+  
+  class EventServer
+  
+    attr_accessor :connection, :appid
+  
+    def initialize(connection,data)
+      @connection = connection
+      @appid = data[:appid]
+    end
+  
+    def self.handle_args(args)
+      {
+        :server => Application.extract_arg("--server",args,"0.0.0.0"),
+        :port => Application.extract_arg("--port",args,"4848"),
+        :appid => Application.extract_arg("--id",args,"myeve")
+      }
+    end
+    
+    def app
+      if @connection.app.nil?
+        @connection.app = Eve::Application.new(:display => { :event_machine => @connection }, :system_calls_display => { :filename => "./eve_server_calls.log" })
+      end
+      @connection.app
+    end
+  
+    def post_init
+      app.cmd("appid #{@appid}")
+    end
+  
+    def receive_data(data)
+      result = app.cmd(data)
+      @connection.close_connection if result[:status] == :exited
+      @connection.send_data("#{app.id}> ")
+      result
+    end
+    
+  end
+
+end

data/lib/eve/file_notifier_server.rb

@@ -0,0 +1,77 @@
+module Eve
+
+  class FileNotifierServer
+
+    attr_accessor :connection, :server, :port, :source, :appid, :callbacks, :inits
+
+    def initialize(connection,data)
+      @connection = connection
+      @server = data[:server]
+      @port = data[:port]
+      @source = data[:source]
+      @appid = data[:appid]
+      @callbacks = data[:callbacks] || []
+      @inits = data[:inits] || []
+    end
+
+    def self.handle_args(args)
+      {
+        :server => Application.extract_arg("--server",args,nil),
+        :port => Application.extract_arg("--port",args,nil),
+        :source => Application.extract_arg("--source",args,nil),
+        :appid => Application.extract_arg("--id",args,nil),
+        :callbacks => Application.extract_arg("--callback",args,[]),
+        :inits => Application.extract_arg("--init",args,[])
+      }
+    end
+    
+    def app
+      if @connection.app.nil?
+        display = :stdio
+        @connection.app = Eve::Application.new(:display => display, :system_calls_display => { :filename => "./eve_system_calls.log" })
+      end
+      @connection.app
+    end
+
+    def post_init
+      if @server.nil?
+        app.cmd("appid #{@appid}")
+      else
+        app.cmd("event #{@server}:#{@port}")  
+      end
+      @inits.each { |x| app.cmd(x) }
+    end
+    
+    def file_modified
+      @callbacks.each { |cb| app.cmd(cb) }
+    end
+    
+  end
+
+  class FileNotifierConnection < EventMachine::FileWatch
+
+    cattr_accessor :data
+    
+    attr_accessor :app
+    attr_accessor :server
+
+    def post_init
+      @server = FileNotifierServer.new(self,@@data)
+      @server.post_init
+    end
+
+    def file_modified
+      @server.file_modified
+    end
+
+    def self.run(args)
+      @@data = FileNotifierServer.handle_args(args)
+      EM.kqueue = true if EM.kqueue? # file watching requires kqueue on OSX
+      EM.run {
+        EM.watch_file(@@data[:source], FileNotifierConnection)
+      }
+    end
+    
+  end
+
+end

data/lib/eve/io.rb

@@ -0,0 +1,25 @@
+class IO
+  def self.write(filename,content)
+    File.open(filename, 'w') {|f| f.write(content) }
+  end
+end
+
+class String
+  def underscore
+    word = self.dup
+    word.gsub!(/::/, '/')
+    word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+    word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+    word.tr!("-", "_")
+    word.downcase!
+    word
+  end
+end
+
+def p?(filename)
+  File.exists?(filename)  
+end
+
+def p(filename)
+  Pathname.new(filename).realpath.to_s
+end

data/lib/eve/layout.rb

@@ -0,0 +1,22 @@
+module Eve
+  
+  class Layout
+   
+    attr_accessor :columns
+    
+    def initialize
+      @columns = []
+    end
+    
+    def add_column(input)
+      return nil if input.nil?
+      parts = input.split(";")
+      return nil if parts.size != 3
+      entry = { :column_type => parts[0].downcase.to_sym, :filter => parts[1], :order => parts[2].to_i  }
+      @columns << entry
+      entry
+    end
+    
+  end
+  
+end

data/lib/eve/message.rb

@@ -0,0 +1,181 @@
+module Eve
+  
+  class Message
+   
+    attr_accessor :app
+    
+    def initialize(app)
+      @app = app
+    end
+    
+    def print_version(appid,show_multiple_times = true)
+      if appid.nil?
+        print "eve, version #{Eve::VERSION}\n"
+      else
+        app_full_id = appid.to_s == $$.to_s ? appid : "#{appid} (#{$$})"
+        print "eve #{app_full_id}, version #{Eve::VERSION}\n"
+      end
+    end
+    
+    def print_error(msg, error)
+      print "#{msg}\n"
+      print "  #{error.message}\n"
+      print "  " + error.backtrace.join("\n  ") + "\n"
+    end
+    
+    def print_system_call(cmd)
+      print "CALLING: #{cmd}\n", {} , "system_calls"
+    end
+    
+    def print_exit
+      print "bye\n"
+    end
+    
+    def print_unknown_cmd(cmd)
+      print "UNKNOWN CMD: #{cmd}\n"
+    end
+    
+    def print_process_id(id)
+      print "Process Id: #{id}\n"
+    end
+
+    def print_ruby_call(call,answer)
+      print "#{call}: #{answer}\n"
+    end
+    
+    def print_shell_mode
+      print "Entering shell mode, to exit this mode, type 'poll'\n"
+    end
+    
+    def print_poll_details(in_secs, cmds)
+      output = Message.friendly_duration(in_secs)
+      if cmds.empty?
+        print "Poll will check every #{output}, but it has nothing to run.\n"  
+      else
+        msg = "Poll will check every #{output}, and send the following events:\n"
+        cmds.each { |cmd| msg += "  - #{cmd}\n" }
+        print msg
+      end
+    end
+    
+    def print_poll_mode(id,in_secs)
+      output = Message.friendly_duration(in_secs)
+      print "Entering poll mode with checks every #{output}, to exit this mode, run 'eve --interrupt #{id}' from another terminal session\n"
+    end
+    
+    def print_event_mode(where)
+      print "Messages will be routed to #{where}\n"
+    end
+    
+    def print_app_interrupted(id)
+      print "Interrupted eve #{id}, should now be in shell mode\n"
+    end
+    
+    def print_sleep(in_secs)
+      friendly = WatchMe::Timer.calculate_duration_to_s(in_secs)
+      seconds = "#{in_secs} seconds"
+      print friendly == seconds ? "Sleeping for #{friendly}\n" : "Sleeping for #{friendly} (#{seconds})\n"
+    end
+    
+    def print_help(cmds,handler = nil)
+      msg = handler.nil? || handler == "" ? "Available commands are:\n" : "Available commands (#{handler}) are:\n"
+      msg += cmds.collect { |call,sub_calls| sub_calls.empty? ? "  #{call}" : "  #{call} [ #{sub_calls.join(" | ")} ]" }.join("\n")
+      msg += "\n"
+      print msg
+    end
+    
+    def print_exported_commands(filename)
+      print "Exported all commands to #{filename} -- reload using 'import #{filename}'\n"
+    end
+    
+    def print_importing_commands(filename)
+      print "Importing comamnds from #{filename}\n"
+    end
+    
+    def print_importing_complete(filename,count)
+      case count
+        when 0
+          print "No commands found!\n"
+        when 1
+          print "Finished importing #{count} command (#{filename})\n"
+        else
+          print "Finished importing #{count} commands (#{filename})\n"
+      end
+    end
+    
+    def print_cmd_error(cmd,e = nil)
+      msg = "An error occurred for '#{cmd}'"
+      e.nil? ? print("#{msg}\n") : print_error(msg,e)
+    end
+    
+    def print_server_init
+      print "Connection Established\n"
+    end
+    
+    def print_appid(appid)
+      print "Appid: #{appid}\n"
+    end
+    
+    def print_unknown_handler(name)
+      print "Unknown handler Blah\n"
+    end
+    
+    def print_registry_reloaded
+      print "Registry reloaded.\n"
+    end
+    
+    def print_registry(registries)
+      if registries.empty?
+        print "Nothing registered.\n"  
+      else
+        msg = "The following has been registered:\n"
+        registries.each do |classname,files|
+          msg += "  - #{classname} (#{files.join(", ")})\n"
+        end
+        print msg
+      end
+    end
+    
+    def print_registry_path(paths)
+      if paths.empty?
+        print "No paths have been provided.\n"
+      else
+        msg = "The following paths have been set:\n"
+        paths.each do |p|
+          msg += "  -- #{p}\n"
+        end
+        print msg
+      end
+      
+    end
+    
+    def self.friendly_now(time = nil)
+      time = Time.now if time.nil?
+      time.strftime("%Y-%m-%d %H:%M:%S")
+    end
+    
+    def self.friendly_duration(in_secs)
+      friendly = WatchMe::Timer.calculate_duration_to_s(in_secs)
+      in_secs_to_s = "#{in_secs} seconds"
+      output = friendly == in_secs_to_s ? friendly : "#{friendly} (#{in_secs} seconds)"
+    end
+
+    private
+   
+      def last_accessed_to_s(input)
+        return "" if input == "" || input.nil?
+        " last accessed #{input}"
+      end
+        
+      def print(msg, raw_options = {}, messenger_name = "console")
+        options = raw_options.clone
+        show_multiple_times = options.delete(:show_multiple_times)
+        show_multiple_times = true if show_multiple_times.nil?
+        as_string = msg
+        return if (!show_multiple_times && @app.console.was_printed?(as_string))
+        @app.send(messenger_name).print as_string, options
+      end
+    
+  end
+  
+end