bmf 0.2.0

data/lib/bmf/lib/folder.rb

@@ -0,0 +1,76 @@
+require_relative "message_store.rb"
+require_relative "thread_status.rb"
+
+class BMF::Folder
+  VALID_FOLDERS = %w{chans inbox sent lists}
+
+  attr_reader :name
+
+  def initialize folder_name
+    raise "Bad folder #{folder_name}" if !VALID_FOLDERS.include?(folder_name)
+    @name = folder_name
+    @messages = BMF::MessageStore.instance.send(folder_name)
+  end
+
+  def new_messages?
+    @messages.each_pair do |address, threads|
+      return true if BMF::ThreadStatus.instance.new_messages_for_address?(address, threads.keys)
+    end
+
+    return false
+  end
+  
+  def messages opts={}
+    msgs = @messages
+    
+    if opts[:sort] == :new
+      msgs = msgs.sort{ |a,b| BMF::MessageStore.instance.address_last_updates[a[0]] <=> BMF::MessageStore.instance.address_last_updates[b[0]] }.reverse
+    end
+
+    msgs
+  end
+  
+  def threads_for_address address, opts={}
+    threads = @messages[address]
+
+    if threads && opts[:sort] == :new
+      threads = threads.sort{ |a,b| BMF::MessageStore.instance.thread_last_updates[address][a[0]] <=> BMF::MessageStore.instance.thread_last_updates[address][b[0]] }.reverse
+    end
+
+    threads
+  end
+  
+  def thread_messages address, thread_name, opts={}
+    threads = threads_for_address(address)
+
+    return nil if threads.nil?
+
+    msgs = threads[thread_name]
+    msgs = [] if msgs.nil?
+
+    if opts[:sort] == :old
+      msgs = msgs.sort { |a,b| BMF::Message.time(a) <=> BMF::Message.time(b) }
+    end
+
+    msgs
+  end
+
+  def delete_thread address, thread
+    msgs = thread_messages(address, thread)
+    return [] if msgs.nil?
+   
+    alerts = []
+
+    msgs.each do |msg|
+      msgid = msg['msgid']
+      if msg['_source'] == 'sent'
+        alerts << (BMF::XmlrpcClient.instance.trashSentMessage(msgid) + msgid)
+      else
+        alerts << (BMF::XmlrpcClient.instance.trashMessage(msgid) + msgid)
+      end
+    end
+    
+    alerts
+  end
+  
+end

data/lib/bmf/lib/message.rb

@@ -0,0 +1,27 @@
+module BMF::Message
+  def self.time(m)
+    time = m['receivedTime']
+    time = m['lastActionTime'] if time.nil?
+    time.to_i
+  end
+
+  def self.sent?(m)
+    !m['lastActionTime'].nil?
+  end
+
+  def self.received?(m)
+    !m['receivedTime'].nil?
+  end
+  
+  def self.sent_or_received m
+    if sent?(m)
+      :sent
+    elsif received?(m)
+      :received
+    else
+      raise "Don't know if #{m.inspect} was sent or received"
+    end
+  end
+  
+
+end

data/lib/bmf/lib/message_store.rb

@@ -0,0 +1,250 @@
+require 'singleton'
+require 'base64'
+require 'json'
+require 'thread'
+
+require_relative 'xmlrpc_client.rb'
+
+class BMF::MessageStore
+  include Singleton
+
+  
+
+  def initialize
+    @messages = {} # messages by msgid
+    @address_last_updates = {}
+    @thread_last_updates = {}
+    @new_messages = 0
+    # update
+  end
+  
+  def log x
+    puts x
+  end
+
+#  attr_reader :messages, :address_last_updates, :thread_last_updates
+
+  def messages
+    Mutex.new.synchronize { @messages.dup.freeze }
+  end
+  
+  def address_last_updates
+    Mutex.new.synchronize { @address_last_updates.dup.freeze }
+  end
+
+  def thread_last_updates
+    Mutex.new.synchronize { @thread_last_updates.dup.freeze }
+  end
+    
+  def update_times m
+    received_time = BMF::Message.time(m)
+    to_address = m["toAddress"]
+
+    # update channel access time
+    @address_last_updates[to_address] ||= 0
+    if @address_last_updates[to_address] < received_time
+      @address_last_updates[to_address] = received_time
+    end
+
+    subject = m["subject"]
+    if subject[0..3] == "Re: "
+      subject = subject[4..-1]
+    end
+    
+    # update thread access time
+    @thread_last_updates[to_address] ||= {}
+    @thread_last_updates[to_address][subject] ||= 0
+    
+    if @thread_last_updates[to_address][subject] < received_time
+      @thread_last_updates[to_address][subject] = received_time
+    end
+  end
+
+  def add_message msgid, m
+    m["message"] = Base64.decode64(m["message"]).force_encoding("utf-8")
+    m["subject"] = Base64.decode64(m["subject"]).force_encoding("utf-8")
+
+    m["subject"] = " " if m["subject"] == ""
+    m["subject"] = "Re:  " if m["subject"] == "Re: "
+
+    @messages[msgid] = m
+
+    to_address = m["toAddress"]
+
+    # Temp hack for lists
+    if to_address == "[Broadcast subscribers]"
+      hack_mailing_list_name =  m["subject"][/\[[^\]]+\]/]
+      
+      hack_mailing_list_name = m["fromAddress"] if hack_mailing_list_name.nil?
+
+      to_address += " " + hack_mailing_list_name
+      m["toAddress"] = to_address
+    end
+  end
+
+  def get_full_message mailbox, msgid
+    msg_json = BMF::XmlrpcClient.instance.send("get#{mailbox.capitalize}MessageByID", msgid)
+    JSON.parse(msg_json)["#{mailbox}Message"][0]
+  end
+  
+
+  def process_messages new_messages, source="inbox"
+    processed_messages = 0
+
+    new_messages.each do |m|
+      msgid = m["msgid"]
+
+      @new_msgids[msgid] = true
+
+      if !@messages.has_key?(msgid)
+        processed_messages += 1
+
+        if m["message"] # cliend doesn't support getXMessageIds, so we already have everything
+          full_message = m
+        else
+          full_message = get_full_message(source, msgid)
+        end
+        
+
+        full_message["_source"] = source
+
+        add_message msgid, full_message
+
+        update_times full_message
+      end
+    end
+
+    log "Added #{processed_messages} messages..." if processed_messages > 0
+
+    processed_messages
+  end
+
+  def init_gc
+    @new_msgids = {}
+  end
+
+  def do_gc
+    deleted_messages = 0
+    @messages.keys.each do |old_msgid|
+      if !@new_msgids[old_msgid]
+        deleted_messages += 1
+        @messages.delete(old_msgid)
+      end
+    end
+
+    log "Deleted #{deleted_messages}..." if deleted_messages > 0
+  end
+
+  def get_all_message_ids mailbox
+    method = "getAll#{mailbox.capitalize}MessageIds"
+    msgids = BMF::XmlrpcClient.instance.send(method)
+    if BMF::XmlrpcClient.is_error?(msgids) && msgids.downcase.include?("invalid method")
+      log "PyBitmessage doesn't support #{method}.  Falling back to getAll#{mailbox.capitalize}Messages.  Using a version of Pybitmessage that supports #{method} will dramatically increase performance"
+      msgids = BMF::XmlrpcClient.instance.send("getAll#{mailbox.capitalize}Messages")
+      JSON.parse(msgids)["#{mailbox}Messages"]
+    else
+      JSON.parse(msgids)["#{mailbox}MessageIds"]
+    end
+  end
+  
+
+  def update
+
+    inbox_messages = get_all_message_ids "inbox"
+    sent_messages = get_all_message_ids "sent"
+    
+    new_messages = 0
+
+    lock = Mutex.new
+    lock.synchronize do
+      init_gc
+
+      new_messages += process_messages(inbox_messages)
+      process_messages(sent_messages, "sent")
+
+      do_gc
+    end
+
+    new_messages
+  end
+  
+  def pop_new_message_count
+    new = 0
+
+    Mutex.new.synchronize do
+      new += @new_messages
+      @new_messages = 0
+    end
+
+    new
+  end
+  
+
+  def by_recipient sent_or_received=:nil
+ 
+    #display messages
+
+    by_recipient = {}
+
+    @messages.each do |id, m|
+      if sent_or_received
+        next if sent_or_received == :sent && !BMF::Message.sent?(m)
+        next if sent_or_received == :received && !BMF::Message.received?(m)
+      end
+      
+      toAddress = m["toAddress"]
+
+      subject = m["subject"]
+      if subject[0..3] == "Re: "
+        subject = subject[4..-1]
+      end
+      
+      by_recipient[toAddress] = {} if !by_recipient[toAddress]
+      by_recipient[toAddress][subject] = [] if !by_recipient[toAddress][subject]
+      by_recipient[m["toAddress"]][subject] << m
+    end
+
+    by_recipient
+  end
+
+  def inbox
+    by_recipient(:received).select do |toAddress, messages|
+      label = if BMF::AddressStore.instance.addresses.has_key? toAddress
+                BMF::AddressStore.instance.addresses[toAddress]['label']
+              else
+                ""
+              end
+      not( label.include?("[chan]") || toAddress.include?("[Broadcast subscribers]"))
+    end
+  end
+
+  def sent
+    by_recipient(:sent).select do |toAddress, messages|
+      label = if BMF::AddressStore.instance.addresses.has_key? toAddress
+                BMF::AddressStore.instance.addresses[toAddress]['label']
+              else
+                ""
+              end
+      not( label.include?("[chan]") || toAddress.include?("[Broadcast subscribers]"))
+    end
+  end
+
+  def lists
+    by_recipient.select do |toAddress, messages|
+      toAddress.include? "[Broadcast subscribers]"
+    end
+  end
+
+  def chans
+    by_recipient.select do |toAddress, messages|
+      label = if BMF::AddressStore.instance.addresses.has_key? toAddress
+                BMF::AddressStore.instance.addresses[toAddress]['label']
+              else
+                ""
+              end
+      label.include?("[chan]")
+    end
+  end
+  
+
+end

data/lib/bmf/lib/settings.rb

@@ -0,0 +1,74 @@
+require "singleton"
+require 'yaml'
+require 'fileutils'
+
+class BMF::Settings
+  include Singleton
+
+  SETTINGS_AND_DESCRIPTIONS = {
+    :server_url => "Url of the BitMessage server to interface with.",
+    :sig => "Signature line to attach to messages.",
+    :default_send_address => "Default FROM address for messages.",
+    :server_interface => "Internet interface to listen on.  Set to 0.0.0.0 to open up BMF to the network.  WARNING!!! Anyone who can access your IP can read/post/delete/etc.",
+    :server_port => "Internet port to listen on.",
+    :display_sanitized_html => "Show sanitized HTML minus scripts, css, and any non-inline images.",
+    :sync_interval => "Frequency to sync inbox with PyBitmessage, in seconds.  Default 60",
+    :user => "username for http basic authentication.  (You should be using https in conjunction with this!)",
+    :password => "password for http basic authentication.  (You should be using https in conjunction with this!)",
+    :https_server_key_file => "file for https key",
+    :https_server_certificate_file => "file for https certificate"
+  }
+
+  DEFAULT_SETTINGS = {"server_url" => 'http://bmf:bmf@localhost:8442/', "display_sanitized_html" => 'no' }
+
+  VALID_SETTINGS = SETTINGS_AND_DESCRIPTIONS.keys
+
+  SETTING_DIR = ".bitmessageforum"
+  SETTINGS_FILE = "settings.yml"
+
+  def self.fully_qualified_filename filename
+    home_dir = ENV["HOME"] || ENV["HOMEPATH"]
+    File.join(home_dir, SETTING_DIR, filename)
+  end
+  
+  def initialize
+    home_dir = ENV["HOME"] || ENV["HOMEPATH"]
+    
+    setting_dir = File.join(home_dir, SETTING_DIR)
+    Dir.mkdir(setting_dir, 0700) if !File.directory? setting_dir
+
+    settings_filename = BMF::Settings.fully_qualified_filename(SETTINGS_FILE)
+
+    if !File.exists? (settings_filename)
+      puts "No existing settings.  Copying defaults into place."
+      @settings = DEFAULT_SETTINGS
+      persist
+    end
+
+    @settings = YAML.load_file(settings_filename)
+  end
+  
+  def update(key, value)
+    raise "Bad setting #{key}.  Allowed settings #{VALID_SETTINGS.inspect}" if !VALID_SETTINGS.include?(key.to_sym)
+    @settings[key] = value
+
+    BMF::XmlrpcClient.instance.initialize_client if key.to_sym == :server_url
+  end
+
+  def persist
+    File.open(BMF::Settings.fully_qualified_filename(SETTINGS_FILE),'w',0600) do |out|
+      out.write(@settings.to_yaml)
+    end
+  end
+
+  def method_missing(meth, *args)
+    if args == [] and VALID_SETTINGS.include?(meth)
+      ret = @settings[meth.to_s]
+      ret = nil if ret == ""
+      return ret
+    else
+      super
+    end
+  end
+
+end

data/lib/bmf/lib/thread_status.rb

@@ -0,0 +1,98 @@
+require 'singleton'
+require 'base64'
+require_relative 'message_store.rb'
+require_relative 'settings.rb'
+
+class BMF::ThreadStatus
+  include Singleton
+
+  STASH_FILE = BMF::Settings.fully_qualified_filename("thread_status_stash")
+
+  def initialize
+    @thread_last_visited = {}
+    load_stash
+  end
+
+  def serialize_stash
+    updates = []
+    @thread_last_visited.each_pair do |address, threads|
+      threads.each_pair do |thread_name, update_time|
+        updates << "#{address}:#{Base64.encode64(thread_name).gsub("\n","\\n")}:#{update_time}"
+      end
+    end
+    
+    updates.join(";")
+  end
+  
+  def deserialize_stash serialized_stash
+    serialized_stash.split(";").each do |stash_line|
+      address, thread, update_time = stash_line.split(':')
+      thread = Base64.decode64(thread.gsub("\\n","\n"))
+      update_time = update_time.to_i
+      thread_visited(address,thread,update_time)
+    end
+  end
+
+  def load_stash
+    if File.exists? STASH_FILE
+      stash = File.open(STASH_FILE).read
+      deserialize_stash stash
+    end
+  rescue Exception => ex # Failure is not an option!
+    puts "@" * 80
+    puts "Error loading ThreadStatus stash."
+    puts "Ignoring so that the app is usable."
+    puts "Please report the following information to the project maintainers"
+    puts
+    puts "Exception: #{ex.message}"
+    puts ex.backtrace.join("\n")
+  end
+  
+  def persist
+    File.open(STASH_FILE,"w",0600) do |f|
+      f.write(serialize_stash)
+    end
+  end
+  
+
+  def thread_last_visited(address, thread)
+    if @thread_last_visited[address] && @thread_last_visited[address][thread]
+      @thread_last_visited[address][thread]
+    else
+      0
+    end
+  end
+  
+  def thread_visited(address, thread, time)
+    @thread_last_visited[address] ||= {}
+    @thread_last_visited[address][thread] ||= 0
+
+    if time > @thread_last_visited[address][thread]
+      @thread_last_visited[address][thread] = time
+    end
+
+    persist
+  end
+
+  def new_messages?(address, thread)
+    if @thread_last_visited[address] && @thread_last_visited[address][thread]
+      last_visited_time = @thread_last_visited[address][thread]
+    else
+      last_visited_time = 0
+    end
+    
+    last_message_time = BMF::MessageStore.instance.thread_last_updates[address][thread]
+
+    raise thread.inspect if last_message_time.nil?
+
+    last_visited_time < last_message_time
+  end
+
+  def new_messages_for_address?(address, threads)
+    return true if !@thread_last_visited[address] # never been updated
+
+    not threads.detect{ |thread| new_messages?(address, thread)}.nil?
+
+  end
+  
+end