mailshears 0.0.1

data/lib/prune/plugins/agendav.rb

@@ -0,0 +1,13 @@
+require 'pg'
+
+require 'prune/prune_plugin'
+require 'rm/plugins/agendav'
+
+# Handle the pruning of Agendav users from its database. This class
+# doesn't need to do anything; by inheriting from {AgendavRm}, we get
+# its {AgendavRm#remove_user} method and that's all we need to prune.
+#
+class AgendavPrune < AgendavRm
+  # Needed for the magic includers <tt>run()</tt> method.
+  include PrunePlugin
+end

data/lib/prune/plugins/davical.rb

@@ -0,0 +1,13 @@
+require 'pg'
+
+require 'prune/prune_plugin'
+require 'rm/plugins/davical'
+
+# Handle the pruning of DAViCal users from its database. This class
+# doesn't need to do anything; by inheriting from {DavicalRm}, we get
+# its {DavicalRm#remove_user} method and that's all we need to prune.
+#
+class DavicalPrune < DavicalRm
+  # Needed for the magic includers <tt>run()</tt> method.
+  include PrunePlugin
+end

data/lib/prune/plugins/dovecot.rb

@@ -0,0 +1,11 @@
+require 'prune/prune_plugin'
+require 'rm/plugins/dovecot'
+
+# Handle the pruning of Dovecot users from its database. This class
+# doesn't need to do anything; by inheriting from {DovecotRm}, we get
+# its {DovecotRm#remove_user} method and that's all we need to prune.
+#
+class DovecotPrune < DovecotRm
+  # Needed for the magic includers <tt>run()</tt> method.
+  include PrunePlugin
+end

data/lib/prune/plugins/postfixadmin.rb

@@ -0,0 +1,13 @@
+require 'prune/prune_plugin'
+require 'rm/plugins/postfixadmin'
+
+# This class does absolutely nothing except allow us to blindly
+# instantiate classes based on the mode name and configured plugins.
+#
+# We don't need the ability to remove "left over" Postfixadmin users
+# or domains, since "left over" is with respect to what's in
+# Postfixadmin itself. The other pruning plugins check themselves
+# against Postfixadmin -- it doesn't make sense to check Postfixadmin
+# against itself.
+#
+class PostfixadminPrune < PostfixadminRm; end

data/lib/prune/plugins/roundcube.rb

@@ -0,0 +1,14 @@
+require 'pg'
+
+require 'prune/prune_plugin'
+require 'rm/plugins/roundcube'
+
+
+# Handle the pruning of Roundcube users from its database. This class
+# doesn't need to do anything; by inheriting from {RoundcubeRm}, we get
+# its {RoundcubeRm#remove_user} method and that's all we need to prune.
+#
+class RoundcubePrune < RoundcubeRm
+  # Needed for the magic includers <tt>run()</tt> method.
+  include PrunePlugin
+end

data/lib/prune/prune_dummy_runner.rb

@@ -0,0 +1,44 @@
+require 'common/runner'
+require 'prune/plugins/postfixadmin'
+require 'rm/rm_dummy_runner'
+
+# Dummy implementation of a {PruneRunner}. Its <tt>run()</tt> method will
+# tell you what would have been pruned, but will not actually perform
+# the operation.
+#
+class PruneDummyRunner
+  include Runner
+
+
+  # Pretend to prune unused domains and users. Some "what if"
+  # information will be output to stdout.
+  #
+  # The prune mode is the main application of the "dummy" runners,
+  # since it performs some computation outside of the plugins
+  # themselves. This lets the user know which users and domains would
+  # be removed and can help prevent mistakes or even find bugs in the
+  # prune code, if it looks like something will be removed that
+  # shouldn't be!
+  #
+  # @param cfg [Configuration] the configuration options to pass to
+  #   the *plugin* we're runnning.
+  #
+  # @param plugin [Class] plugin class that will do the pruning.
+  #
+  def run(cfg, plugin)
+    # We don't want to check the PostfixAdmin database against itself.
+    return if plugin.class == PostfixadminPrune
+
+    pfa = PostfixadminPrune.new(cfg)
+
+    db_users = pfa.list_users()
+    db_domains = pfa.list_domains()
+
+    leftovers  = plugin.get_leftover_users(db_users)
+    leftovers += plugin.get_leftover_domains(db_domains)
+
+    rm_dummy_runner = RmDummyRunner.new()
+    rm_dummy_runner.run(cfg, plugin, *leftovers)
+  end
+
+end

data/lib/prune/prune_plugin.rb

@@ -0,0 +1,66 @@
+require 'common/plugin.rb'
+
+# Plugins for pruning users. By "pruning," we mean the removal of
+# leftover non-PostfixAdmin users after the associated user has been
+# removed from the Postfixadmin database.
+#
+module PrunePlugin
+
+  # Absorb the subclass run() magic from the Plugin::Run module.
+  extend Plugin::Run
+
+  # The runner class associated with pruning plugins.
+  #
+  # @return [Class] the {PruneRunner} class.
+  #
+  def self.runner()
+    return PruneRunner
+  end
+
+
+  # The "dummy" runner class associated with pruning plugins.
+  #
+  # @return [Class] the {PruneDummyRunner} class.
+  #
+  def self.dummy_runner
+    return PruneDummyRunner
+  end
+
+
+  # Determine which domains are "left over" for this plugin. A domain
+  # is considered "left over" if it has been removed from Postfixadmin
+  # but not some other plugin.
+  #
+  # The leftovers are determined with respect to the list *db_domains*
+  # of domains that Postfixadmin knows about.
+  #
+  # @param db_domains [Array<Domain>] a list of domains that are present
+  #   in the Postfixadmin database.
+  #
+  # @return [Array<Domain>] a list of domains known to this plugin but
+  #   not to Postfixadmin.
+  #
+  def get_leftover_domains(db_domains)
+    # WARNING! Array difference doesn't work for some reason.
+    return list_domains().select{ |d| !db_domains.include?(d) }
+  end
+
+
+  # Determine which users are "left over" for this plugin. A user
+  # is considered "left over" if it has been removed from Postfixadmin
+  # but not some other plugin.
+  #
+  # The leftovers are determined with respect to the list *db_users*
+  # of users that Postfixadmin knows about.
+  #
+  # @param db_users [Array<User>] a list of users that are present
+  #   in the Postfixadmin database.
+  #
+  # @return [Array<User>] a list of users known to this plugin but
+  #   not to Postfixadmin.
+  #
+  def get_leftover_users(db_users)
+    # WARNING! Array difference doesn't work for some reason.
+    return list_users().select{ |u| !db_users.include?(u) }
+  end
+end

data/lib/prune/prune_runner.rb

@@ -0,0 +1,34 @@
+require 'common/runner'
+require 'prune/plugins/postfixadmin'
+require 'rm/rm_runner'
+
+# Perform the pruning of users/domains using {PrunePlugin}s.
+#
+class PruneRunner
+  include Runner
+
+  # Run *plugin* to prune leftover users and directories.
+  #
+  # @param cfg [Configuration] configuration options passed to
+  # {PostfixadminPrune}.
+  #
+  # @param plugin [Class] plugin class that will perform the pruning.
+  #
+  def run(cfg, plugin)
+    # We don't want to check the PostfixAdmin database against itself.
+    return if plugin.class == PostfixadminPrune
+
+    pfa = PostfixadminPrune.new(cfg)
+
+    db_users = pfa.list_users()
+    db_domains = pfa.list_domains()
+
+    leftovers  = plugin.get_leftover_users(db_users)
+    leftovers += plugin.get_leftover_domains(db_domains)
+
+    # We're counting on our PrunePlugin also being an RmPlugin here.
+    rm_runner = RmRunner.new()
+    rm_runner.run(cfg, plugin, *leftovers)
+  end
+
+end

data/lib/rm/plugins/agendav.rb

@@ -0,0 +1,38 @@
+require 'pg'
+
+require 'common/agendav_plugin'
+require 'rm/rm_plugin'
+
+
+# Handle the removal of Agendav users from its database. Agendav has
+# no concept of domains.
+#
+class AgendavRm
+
+  include AgendavPlugin
+  include RmPlugin
+
+
+  # Remove *user* from the Agendav database. This should remove him
+  # from _every_ table in which he is referenced.
+  #
+  # @param user [User] the user to remove.
+  #
+  def remove_user(user)
+    raise NonexistentUserError.new(user.to_s()) if not user_exists(user)
+
+    sql_queries = ['DELETE FROM prefs WHERE username = $1;']
+    sql_queries << 'DELETE FROM shared WHERE user_from = $1;'
+
+    connection = PG::Connection.new(@db_hash)
+    begin
+      sql_queries.each do |sql_query|
+        connection.query(sql_query, [user.to_s()])
+      end
+    ensure
+      # Make sure the connection gets closed even if a query explodes.
+      connection.close()
+    end
+  end
+
+end

data/lib/rm/plugins/davical.rb

@@ -0,0 +1,38 @@
+require 'pg'
+
+require 'common/davical_plugin'
+require 'rm/rm_plugin'
+
+# Handle the removal of DAViCal users from its database. DAViCal has
+# no concept of domains.
+#
+class DavicalRm
+
+  include DavicalPlugin
+  include RmPlugin
+
+
+  # Remove *user* from the DAViCal database. This should remove him
+  # from _every_ table in which he is referenced. Fortunately, DAViCal
+  # uses foreign keys properly (and only supports postgres, where they
+  # work!), so we can let the ON DELETE CASCADE trigger handle most of
+  # the work.
+  #
+  # @param user [User] the user to remove.
+  #
+  def remove_user(user)
+    raise NonexistentUserError.new(user.to_s()) if not user_exists(user)
+
+    sql_query = 'DELETE FROM usr WHERE username = $1;'
+
+    connection = PG::Connection.new(@db_hash)
+    begin
+      connection.query(sql_query, [user.to_s()])
+    ensure
+      # Make sure the connection gets closed even if the query explodes.
+      connection.close()
+    end
+  end
+
+
+end

data/lib/rm/plugins/dovecot.rb

@@ -0,0 +1,48 @@
+require 'fileutils'
+
+require 'common/dovecot_plugin'
+require 'rm/rm_plugin'
+
+
+# Handle the removal of users and domains from the Dovecot mailstore
+# (the filesystem).
+#
+class DovecotRm
+
+  include DovecotPlugin
+  include RmPlugin
+
+
+  # Remove *domain* from the Dovecot mailstore. This just runs "rm -r"
+  # on the domain directory if it exists.
+  #
+  # @param domain [Domain] the domain to remove.
+  #
+  def remove_domain(domain)
+    domain_path = self.get_domain_path(domain)
+
+    if not File.directory?(domain_path)
+      raise NonexistentDomainError.new(domain.to_s())
+    end
+
+    FileUtils.rm_r(domain_path)
+  end
+
+
+  # Remove *user* from the Dovecot mailstore. This just runs "rm -r"
+  # on the *user*'s mailbox directory, if it exists.
+  #
+  # @param user [User] the user whose mailbox directory we want to
+  #   remove.
+  #
+  def remove_user(user)
+    user_path = self.get_user_path(user)
+
+    if not File.directory?(user_path)
+      raise NonexistentUserError.new(user.to_s())
+    end
+
+    FileUtils.rm_r(user_path)
+  end
+
+end

data/lib/rm/plugins/postfixadmin.rb

@@ -0,0 +1,114 @@
+require 'pg'
+
+require 'common/postfixadmin_plugin'
+require 'rm/rm_plugin'
+
+
+# Handle the removal of users and domains from the Postfixadmin database.
+#
+class PostfixadminRm
+
+  include PostfixadminPlugin
+  include RmPlugin
+
+
+  # Remove *user* from the Postfixadmin database. This should remove
+  # him from _every_ table in which he is referenced. Unfortunately,
+  # Postfixadmin does not use foreign keys or ON DELETE CASCADE
+  # triggers so we need to delete the associated child table records
+  # ourselves.
+  #
+  # @param user [User] the user to remove.
+  #
+  def remove_user(user)
+    raise NonexistentUserError.new(user.to_s()) if not user_exists(user)
+
+    # Remove aliases FROM our user to some other address.
+    sql_queries = ['DELETE FROM alias WHERE address = $1;']
+
+    # Also delete aliases that point SOLELY TO our user.
+    sql_queries << "DELETE FROM alias WHERE goto = $1;"
+
+    # But aliases don't need to point to a single user! If our user
+    # was part of a multi-recipient alias, we want to remove our user
+    # from the alias and leave the other recipients.
+    #
+    # We want to delete the comma that precedes/follows the address,
+    # too.  Since the address to be replaced can appear at either the
+    # beginning or the end of the list (as well as in the middle), we
+    # have to try to fix both cases: comma before, and comma after.
+    comma_before = "CONCAT(',', $1)"
+    comma_after  = "CONCAT($1, ',')"
+    sql_queries << "UPDATE alias SET goto=REPLACE(goto, #{comma_before}, '');"
+    sql_queries << "UPDATE alias SET goto=REPLACE(goto, #{comma_after}, '');"
+
+    sql_queries << 'DELETE FROM mailbox WHERE username = $1;'
+    sql_queries << 'DELETE FROM quota WHERE username = $1;'
+    sql_queries << 'DELETE FROM quota2 WHERE username = $1;'
+    sql_queries << 'DELETE FROM vacation WHERE email = $1;'
+
+    # Should be handled by a trigger, according to PostfixAdmin code.
+    sql_queries << 'DELETE FROM vacation_notification WHERE on_vacation = $1;'
+
+    connection = PG::Connection.new(@db_hash)
+
+    begin
+      sql_queries.each do |sql_query|
+        varchar = 1043 # from pg_type.h
+        params = [{:value => user.to_s(), :type => varchar}]
+        connection.query(sql_query, params)
+      end
+    ensure
+      # Make sure the connection gets closed even if a query explodes.
+      connection.close()
+    end
+  end
+
+
+  # Remove *domain* from the Postfixadmin database. This should remove
+  # the domain from _every_ table in which it is referenced. It should
+  # also remove every user that belongs to the doomed domain
+  # Postfixadmin has some experimental support for triggers, but they
+  # don't do a very good job of cleaning up. Therefore we remove all
+  # users in the domain manually before removing the domain itself.
+  #
+  # Log entries (from the "log" table) are not removed since they may
+  # still contain valuable information (although they won't mention
+  # this removal).
+  #
+  # @param domain [Domain] the domain to remove.
+  #
+  def remove_domain(domain)
+    raise NonexistentDomainError.new(domain.to_s()) if not domain_exists(domain)
+
+    # First remove all users belonging to the domain. This will handle
+    # alias updates and all the sensitive crap we need to do when
+    # removing a user.
+    users = list_domains_users([domain])
+    users.each { |u| remove_user(u) }
+
+    # The domain_admins table contains one record per domain
+    # (repeating the user as necessary), so this really is sufficient.
+    sql_queries = ['DELETE FROM domain_admins WHERE domain = $1;']
+
+    # Some of the following queries should be redundant now that we've
+    # removed all users in the domain.
+    sql_queries << 'DELETE FROM alias WHERE domain = $1;'
+    sql_queries << 'DELETE FROM mailbox WHERE domain = $1;'
+    sql_queries << 'DELETE FROM alias_domain WHERE alias_domain = $1;'
+    sql_queries << 'DELETE FROM vacation WHERE domain = $1;'
+    sql_queries << 'DELETE FROM domain WHERE domain = $1;'
+
+    connection = PG::Connection.new(@db_hash)
+
+    begin
+      sql_queries.each do |sql_query|
+        connection.query(sql_query, [domain.to_s()])
+      end
+    ensure
+      # Make sure the connection gets closed even if a query explodes.
+      connection.close()
+    end
+  end
+
+end