hope 0.1.0-java

data/lib/hope/server/resources/engine.rb

@@ -0,0 +1,60 @@
+module Hope
+  module Server
+    module Resources
+      module Engine
+
+        def self.registered app
+          app.get "/engines/:engine_id" do
+            content_type :json
+            engine.to_json
+          end
+
+          app.get "/engines" do
+            content_type :json
+            Hope.engines.values.map { |e| e.serializable_hash }.to_json
+          end
+
+          app.put "/engines/:id" do
+            engine_id = params[:id]
+            respond_with(Hope::Engine.get(engine_id) || Hope::Engine.new(engine_id))
+          end
+
+          app.delete "/engines/:id" do
+            e = Hope::Engine.get(params[:id])
+            e.destroy unless e.nil?
+          end
+
+          app.post "/engines" do
+            engine_id = params[:engine_id] || params[:id] || body["name"]
+            if Hope::Engine.get(engine_id)
+              error_with("Engine #{engine_id} already exists") 
+            else
+              respond_with Hope::Engine.new(engine_id)
+            end
+          end
+
+          app.post "/engines/:id/stop" do
+            engine.stop
+            respond_with engine
+          end
+
+          app.post "/engines/:id/start" do
+            engine.start
+            respond_with engine
+          end
+
+          app.post "/engines/:engine_id/subscribe/:src_name" do
+            engine.subscribe params[:src_name]
+            respond_with engine
+          end
+
+          app.post "/engines/:engine_id/unsubscribe/:src_name" do
+            engine.unsubscribe params[:src_name]
+            respond_with engine
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/hope/server/resources/source.rb

@@ -0,0 +1,22 @@
+module Hope
+  module Server
+    module Resources
+      module Source
+
+        def self.registered app
+
+          app.get "/sources" do
+            respond_with Hope::Source.sources.values.map(&:serializable_hash)
+          end
+
+          app.post "/sources" do
+            source_type = body["type"]
+            source_class = Hope::Source.const_get(source_type)
+            src = source_class.new(body["name"], body["opts"])
+          end
+          
+        end
+      end
+    end
+  end
+end

data/lib/hope/server/resources/statement.rb

@@ -0,0 +1,62 @@
+module Hope
+  module Server
+    module Resources
+      module Statement
+
+        def self.registered app
+          
+          # Statements
+          
+          app.get "/engines/:engine_id/statements" do
+            respond_with engine.serializable_hash[:statements]
+          end
+
+          app.get "/engines/:engine_id/statements/:id" do
+            respond_with statement
+          end
+
+          app.post "/engines/:engine_id/statements" do
+            statement_id = body["id"] || body["statement_id"]
+            st = engine.add_epl(body["epl"], body["statement_id"])
+            st.add_listener(Hope::Listener::Base.new(body["id"])) if body["listener"]
+            begin
+              respond_with(st, 201)
+            rescue => err
+              error_with(err, 406)
+            end
+          end
+
+          app.put "/engines/:engine_id/statements/:id" do
+            error_with("You can't update an existing statement", 405)
+          end
+
+          app.delete "/engines/:engine_id/statements/:id" do
+            statement.destroy
+            status 205
+          end
+
+          app.post "/engines/:engine_id/statements/:statement_id/stop" do
+            statement.stop unless statement.stopped?
+            respond_with statement
+          end
+
+          app.post "/engines/:engine_id/statements/:statement_id/start" do
+            statement.start
+            respond_with statement
+          end
+          
+          # Listeners
+          
+          app.get "/engines/:engine_id/statements/:statement_id/listeners" do
+            statement.get_listeners.map { |l| { :name => l.name } }
+          end
+
+          app.post "/engines/:engine_id/statements/:statement_id/listeners" do
+            statement.add_listener Hope::Listener::Base.new(body["name"])
+          end
+          
+        end
+      end
+    end
+  end
+end

data/lib/hope/server/views/app.erb

@@ -0,0 +1,24 @@
+<html>
+  <head>
+    <title>Hope Server v<%= Hope::VERSION %></title>
+    
+    <link rel='stylesheet' href='css/hope.css' type='text/css' media="screen">
+    <link rel='stylesheet' href='css/Aristo/jquery-ui-1.8.7.custom.css' type='text/css' media="screen">
+    <script type="text/javascript" src="js/jquery-1.6.1.js"></script>
+    <script type="text/javascript" src="js/jquery-ui-1.8.14.custom.min.js"></script>
+    <script type="text/javascript" src="js/underscore-1.1.6.js"></script>
+    <script type="text/javascript" src="js/backbone-0.5.1.js"></script>
+    <script type="text/javascript" src="js/inflection.js"></script>
+    <script type="text/javascript" src="js/hope.js"></script>
+    <script type="text/javascript">
+      $(function() {
+        window.hope = Hope.init("hope");
+      })
+    </script>
+  </head>
+  
+  <body>
+    <div id="hope" style="display:none"></div>
+    <div id="loading">loading...</div>
+  </body>
+</html>

data/lib/hope/source.rb

@@ -0,0 +1,20 @@
+module Hope
+  
+  
+  module Source
+
+    def self.sources
+      @sources ||= {}
+    end
+  
+    def self.register src
+      self.sources[src.name] = src
+    end
+  
+    def self.unregister src
+      self.sources.delete src.name
+    end
+  
+  end
+  
+end

data/lib/hope/source/base.rb

@@ -0,0 +1,30 @@
+module Hope
+  class Source::Base
+  
+    attr_reader :name, :options
+    
+    def self.event_types
+      []
+    end
+    
+    # Misc
+    def serializable_hash
+      {
+        :id       => @name,
+        :name     => @name,
+        :type     => self.class.name,
+        :options  => @options,
+        :received => @received
+      }
+    end
+  
+    def to_json
+      serializable_hash.to_json
+    end
+  
+    def parse m
+      JSON.parse m
+    end
+  
+  end
+end

data/lib/hope/source/sub.rb

@@ -0,0 +1,24 @@
+module Hope 
+  class Source::Sub < Hope::Source::Base
+    
+    
+    attr_reader :received
+    
+    def initialize name, opts={}
+      @name = name
+      @socket = opts["socket"] || "ipc://hope"
+      @event_type = opts["event_type"]
+      @received = { :success => 0, :errors => 0, :latest_error => "" }
+      @sub = Hope.ctx.connect ZMQ::SUB, @socket, self
+      @sub.subscribe name
+      Hope::Source.register self
+    end
+    
+    def on_readable(socket, messages)
+      @received[:success] += 1
+      src, evt = messages.map &:copy_out_string
+      Hope.pub.send_msg src, { "data" => evt, "type" => @event_type }.to_json
+    end
+        
+  end
+end

data/lib/hope/source/twitter.rb

@@ -0,0 +1,123 @@
+require 'twitter/json_stream'
+require "logger"
+require "json"
+require 'ostruct'
+
+
+
+module Hope
+  class Source::Twitter < Hope::Source::Base
+    
+    class TwitterUser < Hope::EventType
+      def self.properties
+        {
+          "protected"                           => "bool",
+          "default_profile"                     => "bool",
+          "contributors_enabled"                => "bool",
+          "profile_text_color"                  => "string",
+          "name"                                => "string",
+          "default_profile_image"               => "bool",
+          "profile_sidebar_fill_color"          => "string",
+          "id_str"                              => "string",
+          "profile_background_tile"             => "bool",
+          "utc_offset"                          => "string",
+          "friends_count"                       => "int",
+          "profile_image_url"                   => "string",
+          "is_translator"                       => "bool",
+          "following"                           => "bool",
+          "description"                         => "string",
+          "location"                            => "string",
+          "follow_request_sent"                 => "string",
+          "verified"                            => "bool",
+          "profile_link_color"                  => "string",
+          "followers_count"                     => "int",
+          "screen_name"                         => "string",
+          "profile_sidebar_border_color"        => "string",
+          "url"                                 => "string",
+          "show_all_inline_media"               => "bool",
+          "geo_enabled"                         => "bool",
+          "time_zone"                           => "string",
+          "id"                                  => "long",
+          "notifications"                       => "bool",
+          "profile_use_background_image"        => "bool",
+          "favourites_count"                    => "int",
+          "created_at"                          => "string",
+          "listed_count"                        => "int",
+          "profile_background_image_url_https"  => "string",
+          "profile_background_color"            => "string",
+          "lang"                                => "string",
+          "statuses_count"                      => "int",
+          "profile_background_image_url"        => "string",
+          "profile_image_url_https"             => "string"
+        }
+      end
+    end
+
+    class Tweet < Hope::EventType
+      def self.properties
+        {
+          "place"                               => "string",
+          "user"                                => "TwitterUser",
+          "in_reply_to_user_id"                 => "long",
+          "retweet_count"                       => "int",
+          "id_str"                              => "string",
+          "geo"                                 => "string",
+          "favorited"                           => "bool",
+          "text"                                => "string",
+          "in_reply_to_status_id_str"           => "string",
+          "in_reply_to_screen_name"             => "string",
+          "in_reply_to_user_id_str"             => "string",
+          "coordinates"                         => "string",
+          "truncated"                           => "bool",
+          "contributors"                        => "string",
+          "retweeted"                           => "bool",
+          "id"                                  => "long",
+          "source"                              => "string",
+          "created_at"                          => "string",
+          "in_reply_to_status_id"               => "long"
+        }
+      end
+    end
+    
+    def self.event_types
+      [ TwitterUser, Tweet ]
+    end
+    
+    def initialize(name, opts={})
+      
+      @logger = Logger.new("tmp/#{name}.json")
+      
+      EM::PeriodicTimer.new(1) do
+        puts "#{@received[:success]} tweets Received from Twitter::#{name}"
+      end
+      
+      @name = name
+      @received = { :success => 0, :errors => 0, :latest_error => "" }
+      @options = {}.merge(opts)
+      
+      stream = Twitter::JSONStream.connect(
+        :path    => "/1/statuses/filter.json?track=#{@options["track"]}",
+        :auth    => "#{@options["login"]}:#{@options["password"]}"
+      )
+
+      stream.each_item do |item|
+        # @logger.info(item)
+        @received[:success] += 1
+        tweet = JSON.parse item
+        Hope.pub.send_msg name, { "data" => tweet, "type" => "Tweet" }.to_json
+      end
+
+      stream.on_error do |message|
+        @received[:errors] += 1
+        puts "Error: #{message}"
+      end
+
+      stream.on_max_reconnects do |timeout, retries|
+        @received[:latest_error] = "Max reconnect: #{timeout} || retried #{retries} times..."
+      end
+      
+      Hope::Source.register self
+    end
+
+  end 
+end

data/lib/hope/statement.rb

@@ -0,0 +1,73 @@
+require 'forwardable'
+
+module Hope
+  
+  class Statement
+    
+    java_import com.espertech.esper.client.EPStatementState
+    
+    %w{ STARTED FAILED DESTROYED STOPPED }.each do |c|
+      const_set(c, EPStatementState.valueOf(c))
+    end
+    
+    extend Forwardable
+    
+    attr_reader :ep_statement
+    
+    def_delegator :@ep_statement, :stop,    :stop
+    def_delegator :@ep_statement, :start,   :start
+    def_delegator :@ep_statement, :destroy, :destroy
+    
+    def_delegator :@ep_statement, :getName,                 :name
+    def_delegator :@ep_statement, :getEventType,            :event_type
+    def_delegator :@ep_statement, :getText,                 :text
+    def_delegator :@ep_statement, :getState,                :state
+    def_delegator :@ep_statement, :getUserObject,           :user
+    def_delegator :@ep_statement, :getAnnotations,          :annotations
+    def_delegator :@ep_statement, :getServiceIsolated,      :service_isolated
+
+    def_delegator :@ep_statement, :isPattern,   :pattern?
+
+    def_delegator :@ep_statement, :isStarted,   :started?
+    def_delegator :@ep_statement, :isStopped,   :stopped?
+    def_delegator :@ep_statement, :isDestroyed, :destroyed?
+
+    def_delegator :@ep_statement, :addListener, :add_listener
+    def_delegator :@ep_statement, :getUpdateListeners, :get_listeners
+    def_delegator :@ep_statement, :removeListener, :remove_listener
+    def_delegator :@ep_statement, :removeAllListeners, :remove_all_listeners
+    
+    
+    def to_s
+      "[#{name}:#{event_type}] (#{state}) : #{text}"
+    end
+    
+    def initialize ep_statement
+      @ep_statement = ep_statement
+    end
+
+    def updated_at
+      Time.at(@ep_statement.getTimeLastStateChange / 1000)
+    end
+    
+    def serializable_hash
+      {
+        :id           => name,
+        :name         => name,
+        :text         => text,
+        :updated_at   => updated_at,
+        :state        => state.to_s,
+        :is_pattern   => pattern?,
+        :event_type   => event_type.getName,
+        :is_destroyed => destroyed?,
+        :listeners    => get_listeners.map { |l| l.serializable_hash  }
+      }
+    end
+    
+    def to_json
+      serializable_hash.to_json
+    end
+    
+  end
+  
+end