tweet 0.6

data/lib/tweet.rb

@@ -0,0 +1,437 @@
+#!/usr/bin/ruby
+#
+# = Tweet
+#
+# == Synopsis
+#
+# A generalized notification daemon.  Can be petitioned by an arbitrary
+# application to activate a notification.  Notifications can be customized by
+# the user via a plugin architecture.  Examples include a GTK2 popup dialog, a
+# syslog entry, or an email alert.
+#
+# Can also be required in a ruby script to access a running Tweet daemon (see
+# Tweet.notify, Tweet.message, Tweet.running?, Tweet.stop).
+#
+# The website is here: http://tweet.rubyforge.org/
+#
+# == Installation
+#
+#   gem install tweet
+#
+# or maybe:
+#
+#   sudo gem install tweet
+#
+# == Usage
+#
+#   tweetd [options]
+#
+# == Requirements
+#
+# - Ruby 1.8
+# - daemons library
+# - pidify library
+#
+# == Examples
+#
+# To start the daemon:
+#   tweetd -d
+#
+# To contact the daemon from the shell:
+#   tweet "hello world"
+#
+# To contact the daemon from ruby:
+#   require 'tweet'
+#   Tweet.message("hello world")
+#
+# == Author
+#
+# Payton Swick, 2006
+#
+# == License Creative Commons GPL license.
+# http://creativecommons.org/licenses/GPL/2.0/
+#
+
+module Tweet
+
+  require 'rubygems'
+  require 'gserver'
+  require 'yaml'
+  require 'pidify'
+
+  VERSION = '0.6'
+
+  # Priority levels.
+  # 
+  # They can be referenced from other classes like this:
+  #
+  #   Tweet::PRI['WARNING']
+  PRI = {
+    'CRITICAL' => 1,
+    'WARNING'  => 2,
+    'INFO'     => 3,
+    'LOW'      => 4,
+    'DEBUG'    => 5
+  }
+
+  # The TCP port to listen on.
+  PORT = 9128
+
+  # Enable using syslog for tweetd events (this is different from the syslog
+  # notifier plugin, as it does not log notifications. This logs only tweetd
+  # activity, eg: stopping and starting.)
+  USE_SYSLOG = true
+
+  # Experimental GTK Tray icon.
+  USE_GTK_TRAY_ICON = true
+
+  class << self
+
+    # Given an instance of Note, this will try to contact a running tweet
+    # instance and send a notification.  See Tweet::message for a simpler
+    # version.
+    #
+    # Example: 
+    #   require 'tweet'
+    #   Tweet.notify(Tweet::Note.info("Hello World", "Hello World!", "5", "test application"))
+    def notify(note)
+      require 'net/telnet'
+      message = 'app "'+note.application.to_s+'";priority "'+note.priority.to_s+'";duration "'+note.duration.to_s+'";notifier "'+note.requested_notifiers.join(' ')+'";title "'+note.title.to_s+'";message "'+note.message.to_s+'"'
+      begin
+        conn = Net::Telnet.new({'Host' => 'localhost', 'Port' => PORT, 'Telnet mode' => false })
+      rescue
+        raise "Connection to tweet failed.  Maybe tweetd is not running?"
+      end
+      out = conn.recv(128)
+      raise "While trying to connect to tweetd, server replied: '#{out.chomp}'" if out !~ /^2/
+      conn.write(message+"\n")
+      out = conn.recv(128)
+      raise "While trying to send this: '#{message}', tweetd replied: '#{out.chomp}'" if out !~ /^2/
+      conn.close
+    end
+
+    # Given a String, this will try to contact a running tweet instance and send
+    # the String as a notification from the calling application with a duration
+    # of a number of seconds (the default is a duration of 0 (permanent)).  This
+    # is a simple form of Tweet::notify.
+    #
+    # Example:
+    #   require 'tweet'
+    #   Tweet.message "Hello World!"
+    def message(message, duration=0)
+      notify(Note.info(message, message, duration, $0))
+    end
+
+    # Just like Tweet.message, but allows specifying an array of notifier
+    # plugins to use as requested notifiers on the server.  See Monitor for
+    # more information.
+    def message_with_notifiers(message, notifiers=[], duration=0)
+      notify(Note.new(message, message, duration, Tweet::PRI['INFO'], $0, notifiers))
+    end
+
+    # Returns the path location to the library file.
+    def where_am_i?
+      File.dirname(__FILE__)+'/..'
+    end
+
+    # Returns true if an instance of tweetd is running (or appears to be
+    # running).
+    def running?
+      Pidify.running?
+    end
+
+    # Stops a running instance of tweetd.
+    def stop
+      Pidify.stop
+    end
+
+    def start
+      Pidify.start
+    end
+  end
+
+
+  # Represents a unique notification message.  One of these objects is passed
+  # to the show() method of the Notifier.
+  #
+  # The message can be printed by simply printing the Note or by accessing
+  # note.message.  The Note also contains a title, a duration, a priority,
+  # the application (program) that activated it, the connection method that
+  # it used, and the timestamp of when the message was requested.  All of
+  # these parameters (except for the method and time) rely on the application
+  # being honest, and have no built-in effects.  Any interpretation is done
+  # by the Notifier.
+  #
+  # A Note may also include an array of requested notifiers (see Monitor).
+  class Note
+    attr_reader :title, :message, :time, :duration, :priority, :application, :method_received, :requested_notifiers
+
+    # Creates a new Note.
+    def initialize(title, message, duration, priority, application, notifiers=[], method_received=:built_in)
+      @title, @message, @duration, @priority, @application, @method_received = title, message, duration.to_i, priority.to_i, application, method_received
+      @requested_notifiers = notifiers
+      time = Time.now
+    end
+
+    # Shortcut for calling Note.info with a duration of 0.
+    def Note.simple(message)
+      self.info(message, message, 0, $0)
+    end
+
+    # Shortcut for making a new note with the INFO priority.
+    def Note.info(title, message, duration, application, method_received=:built_in)
+      self.new(title, message, duration, PRI['INFO'], application, [], method_received)
+    end
+
+    # Shortcut for making a new note with the WARNING priority.
+    def Note.warning(title, message, duration, application, method_received=:built_in)
+      self.new(title, message, duration, PRI['WARNING'], application, [], method_received)
+    end
+
+    # Shortcut for making a new note with the LOW priority.
+    def Note.low(title, message, duration, application, method_received=:built_in)
+      self.new(title, message, duration, PRI['LOW'], application, [], method_received)
+    end
+
+    # Shortcut for making a new note with the CRITICAL priority.
+    def Note.critical(title, message, duration, application, method_received=:built_in)
+      self.new(title, message, duration, PRI['CRITICAL'], application, [], method_received)
+    end
+
+    # Shortcut for making a new note with the DEBUG priority.
+    def Note.debug(title, message, duration, application, method_received=:built_in)
+      self.new(title, message, duration, PRI['DEBUG'], application, [], method_received)
+    end
+
+    # Printing the Note prints the message.
+    def to_s
+      @message
+    end
+  end
+
+
+  # Listens on a network port for notifications, firing off the appropriate
+  # action (via a Notifier) when one is received. 
+  #
+  # A proper request looks like this (fields can be in any order, semicolons
+  # not required):
+  #
+  #   app "MyApplication";title "hello world";message "Hello World!";duration "2";priority "3"
+  #
+  # A request may also include a list of requested notifier plugins, space
+  # separated, like this:
+  #
+  #   app "MyApplication";title "hello world";message "Hello World!";duration "2";notifier "MyPlugin1 MyPlugin2";priority "3"
+  #
+  # If the server is configured to allow requested notifiers (see
+  # Monitor.allow_requested_notifiers), then it will try to use the plugins
+  # that were requested instead of the configured notifier plugins for that
+  # request.
+  class Monitor < GServer
+
+    # Don't show (silently drop) notifications of priority under this.
+    attr_accessor :allow_priority
+
+    # A list of the Notifier objects to send notifications to.
+    attr_reader :active_notifiers
+
+    # If true, the client can request a notifier plugins in its request string.
+    attr_accessor :allow_requested_notifiers
+
+    # Creates a new Monitor.  Defaults to showing notifications of INFO
+    # level and higher. Change allow_priority to modify this setting either
+    # here or after the creation of the object.
+    def initialize(allow_priority=PRI['INFO'])
+      super(PORT)
+      @allow_priority = allow_priority
+      @allow_requested_notifiers = true
+      @active_notifiers = []
+
+      Signal.trap('INT') { puts "Tweet stopped by user interrupt."; stop  }
+
+      if USE_SYSLOG
+        begin
+          require 'syslog'
+          @syslog = Syslog.open("tweetd");
+          @syslog.info('tweetd starting.')
+        rescue LoadError
+        end
+      end
+
+      if USE_GTK_TRAY_ICON
+        begin
+          set_up_gtk_tray_icon
+          @syslog.info('gtk tray icon loaded.') if @syslog
+        rescue LoadError
+          @syslog.info('gtk tray icon not loaded.') if @syslog
+        end
+      end
+    end
+
+    def set_up_gtk_tray_icon
+      require 'gtk2'
+      require 'gtktrayicon'
+      Gtk::init
+
+      screen = Gdk::Screen.default
+      @tray = Gtk::TrayIcon.new("tweetd", screen)
+      image_file = File.dirname(__FILE__) + '/../images/comments.png'
+      if File.exist?(image_file)
+        image = Gtk::Image.new(image_file)
+      else
+        @syslog.info("Error, tray image does not exist: #{image_file}") if @syslog
+        image = Gtk::Image.new(Gtk::Stock::DIALOG_INFO, Gtk::IconSize::BUTTON)
+      end
+      button = Gtk::EventBox.new.add(image)
+      menu = Gtk::Menu.new
+
+      quit_item = Gtk::MenuItem.new("Quit Tweetd")
+      quit_item.signal_connect('activate') do
+        stop
+      end
+      menu.append(quit_item)
+
+      menu.show_all
+
+      button.signal_connect('button_press_event') do |widget,event|
+        menu.popup(nil, nil, event.button, event.time)
+      end
+
+      @tray.add(button)
+      @tray.show_all
+      @gtk_thread = Thread.new { Gtk.main }
+    end
+    private :set_up_gtk_tray_icon
+
+    # Instantiates a (registered) Notifier and adds it to the list of active
+    # notifiers for this Watcher. Returns false if it fails.
+    def activate_notifier(name)
+      begin
+        return false unless n = get_notifier(name)
+        @syslog.info("activating notifier: #{n.class}") if @syslog
+        @active_notifiers << n
+        return true
+      rescue Exception=>e
+        @syslog.info("problem activating notifier: #{name} (#{e})") if @syslog
+      end
+      return false
+    end
+
+    # Instantiates a (registered) Notifier and returns it, or returns false if
+    # it failed.
+    def get_notifier(name)
+      begin
+        klass = eval(name)
+        if Notifier.registered_notifiers.include? klass
+          return klass.new
+        else
+          @syslog.info("notifier not registered: #{klass}") if @syslog
+        end
+      rescue Exception=>e
+        @syslog.info("notifier not found: #{name} (#{e})") if @syslog
+      end
+      return false
+    end
+
+    alias_method :old_start, :start
+    def start
+      Pidify.start
+      old_start
+    end
+
+    alias_method :old_stop, :stop
+    def stop
+      @syslog.info('tweetd stopping.') if @syslog
+      Pidify.stop
+      old_stop
+    end
+
+    # Handles incoming TCP connections.
+    def serve(client)
+      client.puts "200 Tweet #{VERSION} ready."
+
+      data = client.gets.chomp
+      unless data =~ /app "([^"]*)"/
+        client.puts "500 I don't know who you are."
+        return
+      end
+      app = $1
+      unless data =~ /title "([^"]*)"/
+        client.puts "500 Title required."
+        return
+      end
+      title = $1
+      unless data =~ /message "([^"]*)"/
+        client.puts "500 Message required."
+        return
+      end
+      message = $1.gsub('\n', "\n")
+      unless data =~ /duration "([^"]*)"/
+        client.puts "500 Duration required."
+        return
+      end
+      duration = $1
+      notifier = ''
+      if data =~ /notifier "([^"]*)"/
+        notifier = $1
+      end
+      unless data =~ /priority "([^"]*)"/
+        client.puts "500 Priority required."
+        return
+      end
+      priority = $1.to_i
+      client.puts "200 Request accepted."
+
+      note = Note.new(title, message, duration, priority, app, notifier.split(' '), :tcp)
+      notify(note) unless priority > @allow_priority
+    end
+
+    # Calls the Notifier#show method for each active notifier.
+    def notify(note)
+      notifiers_to_use = []
+      if @allow_requested_notifiers
+        notifiers_to_use = note.requested_notifiers.collect { |n| get_notifier(n) }
+      end
+      notifiers_to_use = @active_notifiers if notifiers_to_use.empty?
+      notifiers_to_use.each do |n|
+        next unless n and n.respond_to? :show
+        Thread.new { n.show(note) }
+      end
+    end
+  end
+
+
+  # Plugin-based notification mechanism. When a Note is activated, it will
+  # call the Notifier#show method for each subclass of Notifier, which can be
+  # overridden to provide whatever functionality is required.
+  #
+  # Example of a plugin:
+  #
+  #   class MyPlugin < Tweet::Notifier
+  #        def show(e)
+  #            puts "--"
+  #            puts "alert!! there's a message for you: #{e}"
+  #            puts "--"
+  #       end
+  #   end
+  class Notifier
+    # A list of classes to be used as notifiers.
+    @registered_notifiers = []
+
+    class << self; attr_reader :registered_notifiers end
+
+    def Notifier.inherited(sub)
+      Notifier.registered_notifiers << sub
+      begin
+        Syslog.info("registered plugin: #{sub}")
+      rescue
+      end
+    end
+
+    # Override this method in a subclass (child) as a callback 
+    # hook to provide a notification plugin.
+    def show(note)
+      puts "[tweet!] #{note}"
+    end
+  end
+end

data/plugins/simplepop.rb

@@ -0,0 +1,128 @@
+require 'gtk2'
+require 'tweet'
+
+# GTK2 slider-window-based notifier plugin for tweet.
+class SimplePop < Tweet::Notifier
+
+  XSCREENSAVER_WATCH = false
+  
+  def initialize
+    @current_messages = []
+
+    if Gtk.main_level == 0
+      Thread.new do
+        Gtk::init
+        Gtk.main 
+      end
+    end
+
+    @suspend_popups = false
+    if XSCREENSAVER_WATCH
+      begin
+        xscreensaver = `which xscreensaver-command`
+        if xscreensaver
+          Thread.new do
+            File.open("|#{xscreensaver} -watch") do |ss|
+              loop do
+                case ss.gets 
+                when /^LOCK|^BLANK/
+                  @suspend_popups = true
+                when /^UNBLANK/
+                  @suspend_popups = false
+                end
+              end
+            end
+          end
+        end
+      rescue
+      end
+    end
+  end
+
+  def show(note)
+    return if @suspend_popups == true
+
+    # Create a new window.
+    element = SimplePopWindow.new(note, note.duration, @current_messages.last)
+
+    # Add the new window to the list of windows.
+    @current_messages << element
+
+    # Call notify which calls Gtk.main (blocks) until the window is clicked or
+    # times out.
+    element.notify # blocks until hidden.
+
+    # Remove the stored reference to this window.
+    @current_messages.delete element
+  end
+end
+
+
+class SimplePopWindow < Gtk::Window
+
+  attr_reader :start_y
+
+  def initialize(note, duration=0, highest=nil)
+    @note = note
+    @duration = duration
+    @width = 260
+    @height = 80
+
+    super(Gtk::Window::POPUP)
+
+    resize(@width,@height)
+    stick
+    title = @note.title if @note.respond_to? :title
+    title = @note.to_s unless title
+
+    @root_win = Gdk::Window.default_root_window
+    @start_x = @root_win.geometry[2]-@width-10
+    @start_y = @root_win.geometry[3]-@height
+    @start_y = (highest.start_y-@height) if highest.respond_to? :start_y
+    screen_top = 0
+    @start_y = @root_win.geometry[3]-@height if @start_y <= screen_top
+    move(@start_x,@start_y) 
+
+    @note = @note.to_s.gsub("<", "&lt;")
+    @note = @note.to_s.gsub(">", "&gt;")
+
+    @button = Gtk::Button.new
+    frame = Gtk::Frame.new
+    button_box = Gtk::HBox.new(false, 0)
+    image = Gtk::Image.new(Gtk::Stock::DIALOG_WARNING, Gtk::IconSize::DIALOG)
+    label = Gtk::Label.new(@note)
+
+    label.width_chars = (@width-image.width_request)/10
+    col = (@width - image.width_request)/10
+    col = 40
+    wrapped_text = label.text
+    wrapped_text = wrapped_text.gsub(/(.{1,#{col}})( +|$\n?)|(.{1,#{col}})/, "\\1\\3\n")
+    wrapped_text = wrapped_text.split("\n")[0 .. 4].join("\n")
+    label.set_markup("<small>#{wrapped_text}</small>")
+
+    frame.add(button_box)
+    button_box.add(image)
+    button_box.add(label)
+    @button.add(frame)
+
+    @button.signal_connect('clicked') { @sleep_thread.kill if @sleep_thread }
+    add(@button)
+
+    realize
+    @window = window # The GDK window object this uses.
+    show_all
+  end
+
+  # Activates the notification by displaying the window.
+  def notify
+    if @duration < 1
+      @sleep_thread = Thread.new { loop { sleep(0.1) } }
+    else
+      @sleep_thread = Thread.new { sleep(@duration) }
+    end
+    @sleep_thread.join
+    self.destroy
+  end
+end
+
+# SimplePopWindow.new("tweet rocks and is a mild sedative when used with chocolate!", 4).notify

data/plugins/syslog.rb

@@ -0,0 +1,24 @@
+# Notifier for Tweet that logs messages to syslog.
+require 'syslog'
+class SyslogNotifier < Tweet::Notifier
+  def initialize
+    begin
+      @log = Syslog.open("tweetd");
+    rescue
+      @log = Syslog
+    end
+  end
+
+  def show(n)
+    message = n.application+": "+n.message
+    case n.priority
+    when Tweet::PRI['CRITICAL']: @log.crit(message)
+    when Tweet::PRI['WARNING']: @log.warning(message)
+    when Tweet::PRI['INFO']: @log.info(message)
+    when Tweet::PRI['LOW']: @log.notice(message)
+    when Tweet::PRI['DEBUG']: @log.debug(message)
+    else
+      @log.info(message)
+    end
+  end
+end

data/plugins/xosd.rb

@@ -0,0 +1,23 @@
+class XOSDNotifier < Tweet::Notifier
+  def initialize
+    require 'xosd'
+    @display_secs = 1
+    begin
+      @log = Syslog.open("tweetd");
+    rescue
+      @log = Syslog
+    end
+  end
+
+  def show(note)
+    osd = XOSD::Xosd.new 3
+    osd.position = XOSD::MIDDLE
+    osd.align = XOSD::CENTER
+    osd.color = "#00f0f0"
+    osd.outline_offset = 2
+    osd.shadow_offset = 6
+    osd.font = "-adobe-helvetica-*-r-*-*-34"
+    osd.display_message(0, note.to_s)
+    osd.wait @display_secs.to_i
+  end
+end