joggle 0.1.0

data/lib/joggle/jabber/client.rb

@@ -0,0 +1,82 @@
+require 'joggle/pablotron/observable'
+require 'xmpp4r'
+require 'xmpp4r/roster'
+
+module Joggle
+  module Jabber
+    #
+    # Simple XMPP client.
+    #
+    class Client
+      include Joggle::Pablotron::Observable
+
+      DEFAULTS = {
+        'jabber.client.debug' => false,
+      }
+
+      #
+      # Create a new Jabber::Client object.
+      #
+      # Example:
+      #
+      #   # create new client object
+      #   client = Client.new('foo@example.com', 'mysekretpassword')
+      #
+      def initialize(user, pass, opt = {})
+        # parse options
+        @opt = DEFAULTS.merge(opt || {})
+
+        # enable debugging to stdout
+        if @opt['jabber.client.debug']
+          ::Jabber.debug = true
+        end
+
+        # FIXME: this belongs elsewhere
+        Thread.abort_on_exception = false
+
+        # create new jid and client
+        jid = ::Jabber::JID.new(user)
+        available = ::Jabber::Presence.new.set_type(:available)
+        @client = ::Jabber::Client.new(jid)
+        @client.connect
+
+        @client.auth(pass)
+        @client.send(available)
+
+        roster = ::Jabber::Roster::Helper.new(@client)
+
+        @client.add_message_callback do |msg|
+          next unless msg.type == :chat
+          fire('jabber_client_message', msg)
+        end
+
+        @client.add_presence_callback do |old_p, new_p|
+          fire('jabber_client_presence', old_p, new_p)
+        end
+
+        roster.add_subscription_request_callback do |item, presence|
+          from = presence.from
+
+          if fire('before_jabber_client_accept_subscription', from)
+            roster.accept_subscription(from)
+            fire('jabber_client_accept_subscription', from)
+          end
+        end
+      end
+
+      #
+      # Deliver jabber message to user.
+      #
+      # Example:
+      #
+      #   # send message
+      #   client.deliver('foo@example.com', 'hey there!')
+      #
+      def deliver(who, body, type = :chat)
+        msg = ::Jabber::Message.new(who, body)
+        msg.type = type
+        @client.send(msg)
+      end
+    end
+  end
+end

data/lib/joggle/pablotron/cache.rb

@@ -0,0 +1,131 @@
+require 'pp' # debug
+require 'cgi'
+require 'open-uri'
+require 'joggle/pablotron/observable'
+
+module Joggle
+  module Pablotron
+    class Cache
+      include Joggle::Pablotron::Observable
+
+      DEFAULTS = {
+        'user-agent' => "Pablotron-Cacher/0.0.0",
+      }
+
+      def initialize(cache_store, extra_headers = nil)
+        @extras = extra_headers
+        @store = cache_store
+      end
+
+      def self.urlify(base, args = nil, hash = nil)
+        ret = base
+
+        if args && args.size > 0
+          ret = base + '?' + args.map { |k, v| 
+            [k, v].map { |s| CGI.escape(s.to_s) }.join('=') 
+          }.join('&')
+        end
+
+        if hash
+          ret << '#' + hash
+        end
+        
+        # return result
+        ret
+      end
+
+      # delimiter for appending header string to url
+      # (chosen because it won't appear in a valid url)
+      HEADER_DELIM = '://?&#'
+
+      def url_key(url, headers = nil)
+        ret = url
+
+        # append header fragment
+        if headers && headers.size > 0
+          # sort, concatenate, and append headers to url
+          ret += HEADER_DELIM + headers.keys.map { |key| 
+            key.downcase 
+          }.sort.map { |k| 
+            "#{k}:#{headers[k]}" 
+          }.join(',')
+        end
+
+        # return results
+        ret
+      end
+
+      def get(url, headers = nil)
+        ret = nil
+
+        # create store key
+        key = url_key(url, headers)
+
+        # build headers
+        opt = expand_headers(headers)
+
+        # if we have an existing cache entry for this url,
+        # then use the last-modified and etag headers
+        if entry = @store.get_cached(key)
+          opt.update({
+            'if-modified-since' => entry['last'].to_s,
+            'if-none-match'     => entry['etag'],
+          })
+        end
+
+        # fetch url and handle result
+        begin 
+          open(url, opt) do |fh|
+            ret  = fh.read
+
+            # update store
+            @store.add_cached(key, {
+              'last'  => fh.last_modified.to_s || fh.meta['date'],
+              'etag'  => fh.meta['etag'],
+              'data'  => ret.to_s.dup,
+            })
+
+            fire('cache_updated', url, ret)
+          end
+        rescue OpenURI::HTTPError => err
+          case err.io.status.first
+          when  /^304/
+            # not modified
+            ret = entry['data'] 
+            fire('cache_not_modified', url)
+          else
+            # unknown status code
+            fire('cache_http_error', url, err.io.status.first, err.io.status.last)
+          end
+        end
+
+        # return result
+        ret
+      end
+
+      def has?(url, headers = nil)
+        key = url_key(url, headers)
+        @store.has_cached?(key)
+      end
+
+      def delete(url, headers = nil)
+        key = url_key(url, headers)
+        @store.delete_cached(key)
+      end
+
+      private
+
+      def expand_headers(headers = nil)
+        [DEFAULTS, @extras, headers].inject({}) do |ret, hash|
+          if hash && hash.size > 0
+            hash.keys.each do |key|
+              ret[key.downcase] = hash[key]
+            end
+          end
+
+          ret
+        end
+      end
+    end
+  end
+end

data/lib/joggle/pablotron/observable.rb

@@ -0,0 +1,104 @@
+module Joggle
+  module Pablotron
+    module Observable
+      class StopEvent < Exception; end
+
+      def on(ev, &block)
+        d = lazy_observable_init
+
+        # get next id and create new handler
+        ret = (d[:next_id] += 1)
+        h = { :id => ret }
+
+        # set handler type
+        if ev.kind_of?(String) && block
+          h[:fn] = block
+
+          # add handler to handler list and id to id lut
+          d[:handlers][ev] << h
+          d[:id_lut][ret] = ev
+
+        elsif !ev.kind_of?(String) && !block
+          h[:obj] = ev
+          d[:object_handlers] << h
+        else
+          raise "missing listener block"
+        end
+
+        # return id
+        ret
+      end
+
+      def fire(ev, *args)
+        d = lazy_observable_init
+        ret = true
+
+        # get handlers for this event
+        handlers = d[:handlers][ev]
+
+        begin 
+          if handlers.size > 0
+            handlers.each do |handler| 
+              if fn = handler[:fn]
+                # run handler
+                fn.call(self, ev, *args)
+              else
+                # FIXME: do nothing, is this an error?
+              end
+            end
+          end
+
+          # get object handlers
+          handlers = d[:object_handlers]
+
+          if handlers.size > 0
+            handlers.each do |handler|
+              if o = handler[:obj]
+                # build method symbol
+                meth = "on_#{ev}".intern
+
+                # check for method
+                if o.respond_to?(meth)
+                  o.send(meth, self, *args)
+                end
+              else
+                # FIXME: do nothing, is this an error?
+              end
+            end
+          end
+        rescue StopEvent => err
+          fire(ev + '_stopped', err, *args)
+          ret = false
+        end
+
+        # return result
+        ret
+      end
+
+      def un(id)
+        d = lazy_observable_init
+
+        # look in event handlers
+        if ev = d[:id_lut][id]
+          d[:handlers][ev].reject! { |fn| fn[:id] == id }
+        end
+
+        # check object handlers
+        d[:object_handlers].reject! { |o| o[:id] == id }
+
+        nil
+      end
+
+      private
+
+      def lazy_observable_init
+        @__observable_data ||= {
+          :next_id    => 0,
+          :handlers   => Hash.new { |h, k| h[k] = [] },
+          :object_handlers => [],
+          :id_lut     => {},
+        }
+      end
+    end
+  end
+end

data/lib/joggle/runner/pstore.rb

@@ -0,0 +1,252 @@
+begin
+  require 'rubygems'
+rescue LoadError
+  # ignore missing rubygems
+end
+
+require 'pstore'
+require 'logger'
+require 'fileutils'
+require 'joggle/pablotron/cache'
+require 'joggle/version'
+require 'joggle/store/pstore/all'
+require 'joggle/jabber/client'
+require 'joggle/twitter/fetcher'
+require 'joggle/twitter/engine'
+require 'joggle/engine'
+
+module Joggle
+  module Runner
+    #
+    # Basic PStore-backed runner.  Creates all necessary objects from
+    # given config and binds them together.
+    #
+    class PStore
+      PATHS = {
+        'store' => ENV['JOGGLE_STORE_PATH'] || '~/.joggle/joggle.pstore',
+        'log'   => ENV['JOGGLE_LOG_PATH'] || '~/.joggle/joggle.log',
+      }
+
+      DEFAULTS = {
+        # store configuration
+        'runner.store.path'       => File.expand_path(PATHS['store']),
+
+        # log configuration
+        'runner.log.path'         => File.expand_path(PATHS['log']),
+        # FIXME: change to INFO
+        'runner.log.level'        => 'INFO',
+        'runner.log.format'       => '%Y-%m-%dT%H:%M:%S',
+
+        # cache configuration
+        'runner.cache.headers'    => {
+          'user-agent' => "Joggle/#{Joggle::VERSION}",
+        },
+      }
+
+      attr_reader :log, :store, :cache, :fetcher, :tweeter, :client, :engine
+
+      #
+      # Create and run PStore runner object.
+      #
+      def self.run(opt = nil)
+        new(opt).run
+      end
+
+      PATH_KEYS = %w{store log}
+
+      #
+      # Create new PStore runner object from the given options.
+      #
+      def initialize(opt = nil)
+        @opt = DEFAULTS.merge(opt || {})
+
+        # make sure paths exist
+        PATH_KEYS.each do |key|
+          FileUtils.mkdir_p(File.dirname(@opt["runner.#{key}.path"]), {
+            # restict access to owner
+            :mode => 0700
+          })
+        end
+
+        # create logger
+        @log = Logger.new(@opt['runner.log.path'])
+        @log.level = Logger.const_get(@opt['runner.log.level'].upcase)
+        @log.datetime_format = @opt['runner.log.format']
+        @log.info('Log started.')
+
+        # create backing store
+        path = @opt['runner.store.path'] 
+        @log.debug("Creating backing store \"#{path}\".")
+        pstore = ::PStore.new(path)
+        @store = Store::PStore::All.new(pstore)
+      end
+
+      #
+      # Run this runner.
+      #
+      def run
+        # create cache
+        @log.debug('Creating cache.')
+        @cache = Joggle::Pablotron::Cache.new(@store, @opt['runner.cache.headers'])
+
+        # create fetcher
+        @log.debug('Creating twitter fetcher.')
+        @fetcher = Twitter::Fetcher.new(@store, @cache, @opt)
+
+        # create twitter engine
+        @log.debug('Creating twitter engine.')
+        @tweeter = Twitter::Engine.new(@store, @fetcher, @opt)
+        @tweeter.on(self)
+
+        # create jabber client
+        @log.debug('Creating jabber client.')
+        @client = Jabber::Client.new(@opt['jabber.user'], @opt['jabber.pass'], @opt)
+        @client.on(self)
+
+        # create new joggle engine
+        @log.debug('Creating engine.')
+        @engine = Engine.new(@client, @tweeter)
+        @engine.on(self)
+
+        @log.debug('Running engine.')
+        @engine.run
+      end
+
+      #################
+      # log listeners #
+      #################
+      
+      #
+      # Log twitter_engine_register_user events.
+      #
+      # Note: This method is a listener for Twitter::Engine objects; you
+      # should never call it directly.
+      #
+      def on_twitter_engine_register_user(e, who, user, pass)
+        pre = '<Twitter::Engine>'
+        @log.info("#{pre} Registering user: #{who} (xmpp) => #{user} (twitter).")
+      end
+      
+      #
+      # Log twitter_engine_unregister_user events.
+      #
+      # Note: This method is a listener for Twitter::Engine objects; you
+      # should never call it directly.
+      #
+      def on_twitter_engine_unregister_user(e, who)
+        pre = '<Twitter::Engine>'
+        @log.info("#{pre} Unregistering user: #{who} (xmpp).")
+      end
+
+      #
+      # Log twitter_engine_tweet events.
+      #
+      # Note: This method is a listener for Twitter::Engine objects; you
+      # should never call it directly.
+      #
+      def on_twitter_engine_tweet(e, who, msg)
+        pre = '<Twitter::Engine>'
+        @log.info("#{pre} Tweet: #{who}: #{msg}.")
+      end
+
+      #
+      # Log twitter_engine_update events.
+      #
+      # Note: This method is a listener for Twitter::Engine objects; you
+      # should never call it directly.
+      #
+      def on_twitter_engine_update(e, user)
+        pre = '<Twitter::Engine>'
+        @log.info("#{pre} Updating: #{user['who']}.")
+      end
+
+      #
+      # Log engine_update_error events.
+      #
+      # Note: This method is a listener for Joggle::Engine objects; you
+      # should never call it directly.
+      #
+      def on_engine_update_error(e, err) 
+        pre = '<Engine>'
+        @log.warn("#{pre} Twitter update failed: #{err}.")
+      end
+
+      #
+      # Log engine_reply events.
+      #
+      # Note: This method is a listener for Joggle::Engine objects; you
+      # should never call it directly.
+      #
+      def on_engine_reply(e, who, msg)
+        pre = '<Engine>'
+        @log.info("#{pre} Reply: #{who}: #{msg}.")
+      end
+
+      #
+      # Log engine_reply_error events.
+      #
+      # Note: This method is a listener for Joggle::Engine objects; you
+      # should never call it directly.
+      #
+      def on_engine_reply_error(e, who, msg, err) 
+        pre = '<Engine>'
+        @log.warn("#{pre} Reply Error: Couldn't send reply \"#{msg}\" to #{who}: #{err}.")
+      end
+
+      #
+      # Log engine_idle events (debugging only).
+      #
+      # Note: This method is a listener for Joggle::Engine objects; you
+      # should never call it directly.
+      #
+      def on_engine_command(e, who, cmd, arg)
+        pre = '<Engine>'
+        @log.debug("#{pre} Command: #{who}: cmd = #{cmd}, arg = #{arg}.")
+      end
+
+      #
+      # Log engine_command events.
+      #
+      # Note: This method is a listener for Joggle::Engine objects; you
+      # should never call it directly.
+      #
+      def on_engine_command(e, who, cmd, arg)
+        pre = '<Engine>'
+        @log.info("#{pre} Command: #{who}: cmd = #{cmd}, arg = #{arg}.")
+      end
+
+      #
+      # Log engine_message events.
+      #
+      # Note: This method is a listener for Joggle::Engine objects; you
+      # should never call it directly.
+      #
+      def on_engine_message(e, who, msg)
+        pre = '<Engine>'
+        @log.info("#{pre} Message: #{who}: #{msg}.")
+      end
+
+      #
+      # Log engine_ignored_message events.
+      #
+      # Note: This method is a listener for Joggle::Engine objects; you
+      # should never call it directly.
+      #
+      def on_engine_ignored_message(e, who, msg)
+        pre = '<Engine>'
+        @log.info("#{pre} IGNORED: #{who}: #{msg}.")
+      end
+
+      #
+      # Log engine_ignored_subscription events.
+      #
+      # Note: This method is a listener for Joggle::Engine objects; you
+      # should never call it directly.
+      #
+      def on_engine_ignored_subscription(e, who)
+        pre = '<Engine>'
+        @log.info("#{pre} IGNORED: #{who} (subscription)")
+      end
+    end
+  end
+end

data/lib/joggle/store/pstore/all.rb

@@ -0,0 +1,26 @@
+require 'joggle/store/pstore/cache'
+require 'joggle/store/pstore/message'
+require 'joggle/store/pstore/user'
+
+module Joggle
+  module Store
+    module PStore
+      #
+      # Wrap all store backends into one object.
+      #
+      class All
+        include Cache
+        include Message
+        include User
+
+        #
+        # Create new Joggle::Store::PStore::All object from given
+        # ::PStore object.
+        #
+        def initialize(store)
+          @store = store
+        end
+      end
+    end
+  end
+end

data/lib/joggle/store/pstore/cache.rb

@@ -0,0 +1,65 @@
+require 'digest/md5'
+
+module Joggle
+  module Store
+    module PStore
+      #
+      # Mixin that implements cache store methods for PStore backend.
+      #
+      # Note: You're probably looking for Joggle::Store::PStore::All
+      #
+      module Cache
+        #
+        # Add cache entry.
+        #
+        def add_cached(key, row)
+          key = cache_store_key(key)
+
+          @store.transaction do |s|
+            s[key] = {}.merge(row)
+          end
+        end
+
+        #
+        # Get cache entry.
+        #
+        def get_cached(key)
+          key = cache_store_key(key)
+
+          @store.transaction(true) do |s|
+            s[key]
+          end
+        end
+
+        #
+        # Does the given entry exist?
+        #
+        def has_cached?(key)
+          key = cache_store_key(key)
+
+          @store.transaction(true) do |s|
+            s.root?(key)
+          end
+        end
+
+        #
+        # Delete the given entry.
+        #
+        def delete_cached(key)
+          key = cache_store_key(key)
+
+          @store.transaction do |s|
+            s.delete(key)
+          end
+        end
+
+        #
+        # Map the given key to a pstore root key.
+        #
+        def cache_store_key(key)
+          'cache-' << Digest::MD5.hexdigest(key)
+        end
+      end
+    end
+  end
+end

data/lib/joggle/store/pstore/message.rb

@@ -0,0 +1,54 @@
+require 'digest/md5'
+
+module Joggle
+  module Store
+    module PStore
+      #
+      # Mixin that implements message store methods for pstore objects
+      #
+      # Note: You're probably looking for Joggle::Store::PStore::All
+      #
+      module Message
+        #
+        # Add message to store.
+        #
+        def add_message(key, row)
+          key = message_store_key(key)
+
+          @store.transaction do |s|
+            s[key] = row
+          end
+        end
+
+        #
+        # Does the given message exist in this store?
+        #
+        def has_message?(key)
+          key = message_store_key(key)
+
+          @store.transaction(true) do |s|
+            s.root?(key)
+          end
+        end
+
+        #
+        # Delete the given message.
+        #
+        def delete_message(key)
+          key = message_store_key(key)
+
+          @store.transaction do |s|
+            s.delete(key)
+          end
+        end
+
+        #
+        # Map given key to PStore root key.
+        #
+        def message_store_key(key)
+          'message-' << Digest::MD5.hexdigest(key.to_s)
+        end
+      end
+    end
+  end
+end