mailshears 0.0.1

data/lib/common/user_interface.rb

@@ -0,0 +1,53 @@
+# Class methods for the creation and manipulation of our command-line
+# user interface.
+#
+class UserInterface
+
+  # Construct a usage string showing how to invoke the program.
+  #
+  # @param program_name [String] the name of this program, used to
+  #   construct the usage string.
+  #
+  # @return [String] a string showing the format of a correct program
+  #   invocation.
+  #
+  def self.usage(program_name)
+    return "#{program_name} [prune | rm <target> | mv <src> <dst>]"
+  end
+
+
+  # Construct the header that precedes our other output. An example is,
+  #
+  #   mailshears, 2015-11-06 09:57:06 -0500 (Plugin: PrunePlugin)
+  #   ------------------------------------------------------------
+  #
+  # @param program_name [String] the name of this program, to appear
+  #   in the header.
+  #
+  # @param plugin_name [String] the name of the mode (prune, mv, etc.)
+  #   plugin that is being run.
+  #
+  # @return [String] a string containing the output header.
+  #
+  def self.make_header(program_name, plugin_name)
+    header = "#{program_name}, "
+
+    current_time = Time.now()
+    if current_time.respond_to?(:iso8601)
+      # Somehow this method is missing on some machines.
+      header += current_time.iso8601.to_s()
+    else
+      # Fall back to whatever this looks like.
+      header += current_time.to_s()
+    end
+
+    header += ' (Plugin: ' + plugin_name + ")\n"
+
+     # Underline the header, accounting for the newline.
+    header += '-' * (header.size() - 1)
+
+    return header
+  end
+
+
+end

data/lib/mailshears.rb

@@ -0,0 +1,7 @@
+# Load only the files needed by our executable. The library files are
+# supposed to require what they need themselves.
+
+require 'common/configuration'
+require 'common/errors'
+require 'common/exit_codes'
+require 'common/user_interface'

data/lib/mv/mv_dummy_runner.rb

@@ -0,0 +1,45 @@
+require 'common/runner'
+
+# Dummy implementation of a {MvRunner}. Its <tt>run()</tt> method will
+# tell you what would have been moved, but will not actually perform
+# the operation.
+#
+class MvDummyRunner
+  include Runner
+
+  # Pretend to move *src* to *dst* with *plugin*. Some "what if"
+  # information will be output to stdout. This is useful to see if
+  # there would be (for example) a username collision at *dst* before
+  # attempting the move in earnest.
+  #
+  # @param cfg [Configuration] the configuration options to pass to
+  #   the *plugin* we're runnning.
+  #
+  # @param plugin [Class] plugin class that will perform the move.
+  #
+  # @param src [User] the source user to be moved.
+  #
+  # @param dst [User] the destination user, to which we will move *src*.
+  #
+  def run(cfg, plugin, src, dst)
+
+    if src.is_a?(Domain) or dst.is_a?(Domain) then
+      msg = 'only users can be moved'
+      raise NotImplementedError.new(msg)
+    end
+
+    # Since we're not actually moving anything, the destination
+    # description is really only useful for seeing whether or not we'd
+    # be trying to move in on top of an existing account.
+    src_description = plugin.describe(src)
+    dst_description = plugin.describe(dst)
+
+    msg  = "Would move user "
+    msg += add_description(src, src_description)
+    msg += " to "
+    add_description(dst, dst_description)
+    msg += "."
+    report(plugin, msg)
+  end
+
+end

data/lib/mv/mv_plugin.rb

@@ -0,0 +1,40 @@
+require 'common/plugin.rb'
+
+# Plugins for moving (renaming) users. Moving domains is not supported.
+#
+module MvPlugin
+
+  # Absorb the subclass run() magic from the Plugin::Run module.
+  extend Plugin::Run
+
+  # The runner class associated with move plugins.
+  #
+  # @return [Class] the {MvRunner} class.
+  #
+  def self.runner()
+    return MvRunner
+  end
+
+
+  # The "dummy" runner class associated with move plugins.
+  #
+  # @return [Class] the {MvDummyRunner} class.
+  #
+  def self.dummy_runner()
+    return MvDummyRunner
+  end
+
+
+  # The interface for the "move a user" operation. Subclasses need to
+  # implement this method so that it moves (renames) the user *src* to
+  # the user *dst*.
+  #
+  # @param src [User] the source user to be moved.
+  #
+  # @param dst [User] the destination user to which we'll move *src*.
+  #
+  def mv_user(src, dst)
+    raise NotImplementedError
+  end
+
+end

data/lib/mv/mv_runner.rb

@@ -0,0 +1,56 @@
+require 'common/domain'
+require 'common/errors'
+require 'common/runner'
+
+# Perform the moving (renaming) of users/domains using {MvPlugin}s.
+#
+class MvRunner
+  include Runner
+
+  # Run *plugin* to move the user *src* to *dst*. The method
+  # signature includes the unused *cfg* for consistency with the
+  # runners that do need a {Configuration}.
+  #
+  # @param cfg [Configuration] unused.
+  #
+  # @param plugin [Class] plugin class that will perform the move.
+  #
+  # @param src [User] the source user to be moved.
+  #
+  # @param dst [User] the destination user being moved to.
+  #
+  def run(cfg, plugin, src, dst)
+
+    if src.is_a?(Domain) or dst.is_a?(Domain) then
+      msg = 'only users can be moved'
+      raise NotImplementedError.new(msg)
+    end
+
+    begin
+      src_description = plugin.describe(src)
+      plugin.mv_user(src, dst)
+      dst_description = plugin.describe(dst)
+
+      msg  = "Moved user "
+      msg += add_description(src, src_description)
+      msg += " to "
+      msg += add_description(dst, dst_description)
+      msg += "."
+      report(plugin, msg)
+
+    rescue NonexistentUserError => e
+      # This means that the SOURCE user didn't exist, since a
+      # nonexistent destination user is perfectly expected.
+      report(plugin, "Source user #{src.to_s()} not found.")
+    rescue NonexistentDomainError => e
+      # This could mean that the source domain doesn't exist, but in
+      # that case, we just report that the source user doesn't
+      # exist. So a nonexistent domain refers to a nonexistent
+      # DESTINATION domain.
+      report(plugin, "Destination domain #{dst.domainpart()} not found.")
+    rescue UserAlreadyExistsError => e
+      report(plugin, "Destination user #{dst.to_s()} already exists.")
+    end
+  end
+
+end

data/lib/mv/plugins/agendav.rb

@@ -0,0 +1,46 @@
+require 'pg'
+
+require 'common/agendav_plugin'
+require 'mv/mv_plugin'
+
+
+# Handle moving (renaming) Agendav users in its database. Agendav has
+# no concept of domains.
+#
+class AgendavMv
+
+  include AgendavPlugin
+  include MvPlugin
+
+  # Move the user *src* to *dst* within the Agendav database. This
+  # should "rename" him in _every_ table where he is referenced.
+  #
+  # This can fail is *src* does not exist, or if *dst* already exists
+  # before the move. It should also be an error if the destination
+  # domain doesn't exist. But Agendav doesn't know about domains, so
+  # we let that slide.
+  #
+  # @param src [User] the source user to be moved.
+  #
+  # @param dst [User] the destination user being moved to.
+  #
+  def mv_user(src, dst)
+    raise NonexistentUserError.new(src.to_s()) if not user_exists(src)
+    raise UserAlreadyExistsError.new(dst.to_s()) if user_exists(dst)
+
+    sql_queries = ['UPDATE prefs SET username = $1 WHERE username = $2;']
+    sql_queries << 'UPDATE shared SET user_from = $1 WHERE user_from = $2;'
+    sql_queries << 'UPDATE shared SET user_which = $1 WHERE user_which = $2;'
+
+    connection = PG::Connection.new(@db_hash)
+    begin
+      sql_queries.each do |sql_query|
+        connection.query(sql_query, [dst.to_s(), src.to_s()])
+      end
+    ensure
+      # Make sure the connection gets closed even if a query explodes.
+      connection.close()
+    end
+  end
+
+end

data/lib/mv/plugins/davical.rb

@@ -0,0 +1,43 @@
+require 'pg'
+
+require 'common/davical_plugin'
+require 'rm/rm_plugin'
+
+# Handle moving (renaming) DAViCal users in its database. DAViCal has
+# no concept of domains.
+#
+class DavicalMv
+  include DavicalPlugin
+  include MvPlugin
+
+
+  # Move the user *src* to *dst* within the DAViCal database. This
+  # should "rename" him in _every_ table where he is referenced.
+  # DAViCal uses foreign keys properly, so we let the ON UPDATE
+  # CASCADE trigger handle most of the work.
+  #
+  # This can fail is *src* does not exist, or if *dst* already exists
+  # before the move. It should also be an error if the destination
+  # domain doesn't exist. But DAViCal doesn't know about domains, so
+  # we let that slide.
+  #
+  # @param src [User] the source user to be moved.
+  #
+  # @param dst [User] the destination user being moved to.
+  #
+  def mv_user(src, dst)
+    raise NonexistentUserError.new(src.to_s()) if not user_exists(src)
+    raise UserAlreadyExistsError.new(dst.to_s()) if user_exists(dst)
+
+    sql_query = 'UPDATE usr SET username = $1 WHERE username = $2;'
+
+    connection = PG::Connection.new(@db_hash)
+    begin
+      connection.query(sql_query, [dst.to_s(), src.to_s()])
+    ensure
+      # Make sure the connection gets closed even if the query explodes.
+      connection.close()
+    end
+  end
+
+end

data/lib/mv/plugins/dovecot.rb

@@ -0,0 +1,64 @@
+require 'fileutils'
+
+require 'common/filesystem'
+require 'common/dovecot_plugin'
+require 'mv/mv_plugin'
+
+
+# Handle moving (renaming) Dovecot users on the filesystem.
+#
+class DovecotMv
+
+  include DovecotPlugin
+  include MvPlugin
+
+
+  # Move the Dovecot user *src* to *dst*. This relocates the user's
+  # directory within the Dovecot mailstore (on the filesystem).
+  #
+  # This fails if the source user does not exist, or if the
+  # destination user already exists before the move.
+  #
+  # But is it an error if the target domain does not exist? That's a
+  # bit subtle... The domain may exist in the database, but if it
+  # has not received any mail yet, then its directory won't exist
+  # on-disk.
+  #
+  # There are two possible "oops" scenarios resulting from the fact
+  # that we may run either the Postfixadmin move first or the
+  # Dovecot move first. If we move the user in the database, we
+  # definitely want to move him on disk (that is, we should create
+  # the directory here). But if we move him on disk first, then we
+  # don't know if the database move will fail! We don't want to move
+  # his mail files if he won't get moved in the database.
+  #
+  # Faced with two equally-bad (but easy-to-fix) options, we do the
+  # simplest thing and fail if the destination domain directory
+  # doesn't exist. If nothing else, this is at least consistent.
+  #
+  # @param src [User] the source user to be moved.
+  #
+  # @param dst [User] the destination user being moved to.
+  #
+  def mv_user(src, dst)
+    raise NonexistentUserError.new(src.to_s()) if not user_exists(src)
+    raise UserAlreadyExistsError.new(dst.to_s()) if user_exists(dst)
+
+    # See the docstring...
+    if not self.domain_exists(dst.domain()) then
+      raise NonexistentDomainError.new(dst.domainpart())
+    end
+
+    # We may need to create the target domain directory, even if the
+    # domain exists in the database.
+    FileUtils.mkdir_p(self.get_domain_path(dst.domain()))
+
+    # The parent of dst_path exists because we just created it.The
+    # source path should exist too, because the "source user" does,
+    # and, well, how did we determine that?
+    src_path = self.get_user_path(src)
+    dst_path = self.get_user_path(dst)
+    FileUtils.mv(src_path, dst_path)
+  end
+
+end

data/lib/mv/plugins/postfixadmin.rb

@@ -0,0 +1,70 @@
+require 'pg'
+
+require 'common/postfixadmin_plugin'
+require 'mv/mv_plugin'
+
+
+# Handle moving (renaming) of users in the Postfixadmin database.
+#
+class PostfixadminMv
+
+  include PostfixadminPlugin
+  include MvPlugin
+
+
+  # Move the user *src* to *dst* within the Postfixadmin
+  # database. This should "rename" him in _every_ table where he is
+  # referenced. Unfortunately that must be done manually.
+  #
+  # This can fail is *src* does not exist, or if *dst* already exists
+  # before the move. It will also fail if the domain associated with
+  # the user *dst* does not exist.
+  #
+  # @param src [User] the source user to be moved.
+  #
+  # @param dst [User] the destination user being moved to.
+  #
+  def mv_user(src, dst)
+    raise NonexistentUserError.new(src.to_s()) if not user_exists(src)
+
+    if not domain_exists(dst.domain())
+      raise NonexistentDomainError.new(dst.domain.to_s())
+    end
+
+    raise UserAlreadyExistsError.new(dst.to_s()) if user_exists(dst)
+
+    mailbox_query  = 'UPDATE mailbox SET '
+    mailbox_query += '  username=$1,'
+    mailbox_query += '  domain=$2,'
+    mailbox_query += "  maildir=CONCAT($2, '/', $3, '/'),"
+    mailbox_query += '  local_part=$3 '
+    mailbox_query += 'WHERE username=$4;'
+
+    alias_query1  = 'UPDATE alias SET '
+    alias_query1 += '  address=$1,'
+    alias_query1 += '  domain=$2,'
+    alias_query1 += '  goto=REPLACE(goto, $4, $1) '
+    alias_query1 += 'WHERE address=$4;'
+
+    alias_query2  = 'UPDATE alias SET '
+    alias_query2 += 'goto=REPLACE(goto, $4, $1);'
+
+    sql_queries = [mailbox_query, alias_query1, alias_query2]
+
+    connection = PG::Connection.new(@db_hash)
+    begin
+      sql_queries.each do |sql_query|
+        varchar = 1043 # from pg_type.h
+        params = [{:value => dst.to_s(), :type => varchar},
+                  {:value => dst.domainpart(), :type => varchar},
+                  {:value => dst.localpart(), :type => varchar},
+                  {:value => src.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
+
+end

data/lib/mv/plugins/roundcube.rb

@@ -0,0 +1,44 @@
+require 'pg'
+
+require 'common/roundcube_plugin'
+require 'mv/mv_plugin'
+
+# Handle moving (renaming) of users in the Roundcube
+# database. Roundcube has no concept of domains.
+#
+class RoundcubeMv
+
+  include RoundcubePlugin
+  include MvPlugin
+
+
+  # Move the user *src* to *dst* within the Roundcube database. This
+  # should "rename" him in _every_ table where he is referenced.
+  # Roundcube uses foreign keys properly, so we let the ON UPDATE
+  # CASCADE trigger handle most of the work.
+  #
+  # This can fail is *src* does not exist, or if *dst* already exists
+  # before the move. It should also be an error if the destination
+  # domain doesn't exist. But Roundcube doesn't know about domains, so
+  # we let that slide.
+  #
+  # @param src [User] the source user to be moved.
+  #
+  # @param dst [User] the destination user being moved to.
+  #
+  def mv_user(src, dst)
+    raise NonexistentUserError.new(src.to_s()) if not user_exists(src)
+    raise UserAlreadyExistsError.new(dst.to_s()) if user_exists(dst)
+
+    sql_query = 'UPDATE users SET username = $1 WHERE username = $2;'
+
+    connection = PG::Connection.new(@db_hash)
+    begin
+      connection.query(sql_query, [dst.to_s(), src.to_s()])
+    ensure
+      # Make sure the connection gets closed even if the query explodes.
+      connection.close()
+    end
+  end
+
+end