X-Git-Url: http://gitweb.michael.orlitzky.com/?p=mailshears.git;a=blobdiff_plain;f=bin%2Fmailshears;h=f7b1963cc8bde0a49cfc388fa29d963cf8e3db55;hp=fc20dd3b4b7302ce536e90210d87cad474ad1e34;hb=72696d3f6e95ef773af9727e9c3459b9038b0fc2;hpb=da71911046617ccffbb899b57162c5e6bdbb37ee diff --git a/bin/mailshears b/bin/mailshears index fc20dd3..f7b1963 100755 --- a/bin/mailshears +++ b/bin/mailshears @@ -2,70 +2,133 @@ # # mailshears, to prune unused mail directories. # -# Mail accounts for virtual hosts are stored in SQL, and managed by +# Mail users for virtual hosts are stored in SQL, and managed by # Postfixadmin. However, the physical directories are handled by # Postfix/Dovecot and are left untouched by Postfixadmin. This is good # for security, but comes at a cost: Postfixadmin can't remove a # user's mail directory when his or her account is deleted. # -# This program compares the list of filesystem accounts with the ones -# in the database. It outputs any accounts that exist in the +# This program compares the list of filesystem users with the ones +# in the database. It outputs any users that exist in the # filesystem, but not the database. # -# We need Pathname to get the real filesystem path -# of this script (and not, for example, the path of -# a symlink which points to it. -require 'pathname' - -# This bit of magic adds the parent directory (the -# project root) to the list of ruby load paths. -# Thus, our require statements will work regardless of -# how or from where the script was run. -executable = Pathname.new(__FILE__).realpath.to_s -$: << File.dirname(executable) + '/../' - -# Load our config file. -require 'bin/configuration' - -# And the necessary classes. -require 'src/errors.rb' -require 'src/exit_codes.rb' -require 'src/dovecot_mailstore' -require 'src/postfixadmin_db' - -dms = DovecotMailstore.new(Configuration::MAIL_ROOT) - -pgadb = PostfixadminDb.new(Configuration::DBHOST, - Configuration::DBPORT, - Configuration::DBOPTS, - Configuration::DBTTY, - Configuration::DBNAME, - Configuration::DBUSER, - Configuration::DBPASS) - -begin - # Get the list of accounts according to the filesystem. - fs_accts = dms.get_accounts_from_filesystem() -rescue StandardError => e - puts "There was an error retrieving accounts from the filesystem: #{e.to_s}" - Kernel.exit(ExitCodes::FILESYSTEM_ERROR) +# Define a usage string using the program name. +exe = File.basename($PROGRAM_NAME) +usage = "#{exe} [prune | rm | mv ]" + +# Defaults +mode_name = 'prune' +mode = :prune + +# Now, if a mode was supplied, it should be in ARGV[0]. +if ARGV.length() > 0 + mode_names = ['prune', 'rm', 'mv'] + if mode_names.include?(ARGV.first().downcase()) then + # Peel the mode name off the head of the list. + mode_name = ARGV.shift() + end +end + +if mode_name == 'rm' then + mode = :rm +elsif mode_name == 'mv' then + mode = :mv +end + +# Need this before referencing ExitCodes. +require 'mailshears' + +# Since we removed both the executable name and the mode name (if it +# existed) from ARGV, what remains should be the required +# arguments. +if (mode == :prune and (ARGV.length() != 0)) or + (mode == :rm and (ARGV.length() < 1)) or + (mode == :mv and (ARGV.length() != 2)) then + puts "ERROR: missing (or extra) command-line arguments." + puts "Usage: #{usage}" + Kernel.exit(ExitCodes::BAD_COMMAND_LINE) +end + +cfg = Configuration.new() + +# Load each of the plugins that we'll need. +cfg.plugins.each do |plugin_file| + require "#{mode_name}/plugins/#{plugin_file}" +end + +# And the runners. +require "#{mode_name}/#{mode_name}_runner" +require "#{mode_name}/#{mode_name}_dummy_runner" + +def make_header(plugin_name) + # The header that we output before the list of domains/users. + # Just the path of this script, the current time, and the plugin name. + exe = File.basename($PROGRAM_NAME) + header = "#{exe}, " + + 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" + header += '-' * header.size # Underline the header. + + return header end -begin - # ...and according to the Postfixadmin database. - db_accts = pgadb.get_accounts_from_db() -rescue DatabaseError => e - puts "There was an error connecting to the database: #{e.to_s}" - Kernel.exit(ExitCodes::DATABASE_ERROR) + +plugin_class = nil +runner_class = nil +dummy_runner_class = nil + +if mode == :rm then + plugin_class = RmPlugin + runner_class = RmRunner + dummy_runner_class = RmDummyRunner +elsif mode == :mv then + plugin_class = MvPlugin + runner_class = MvRunner + dummy_runner_class = MvDummyRunner +else + # Safe, catch-all default + plugin_class = PrunePlugin + runner_class = PruneRunner + dummy_runner_class = PruneDummyRunner end -# Figure out which addresses are in the filesystem, but not in the -# database. -difference = [fs_accts - db_accts] +# Buffer the output so that we can avoid printing the informational +# header when no plugins produce output. +require 'stringio' +output_buffer = StringIO.new() +$stdout = output_buffer + +plugin_class.includers.each do |plugin_class_includer| + plugin = plugin_class_includer.new(cfg) + + if cfg.i_mean_business then + runner = runner_class.new() + else + runner = dummy_runner_class.new() + end + + # The splat passes the correct (we hope) number of arguments to the + # appropriate runner. The Rm(Dummy)Runner have splats on their + # *target arguments as well, to turn ARGV back into an array. + runner.run(plugin, *ARGV) +end -# Don't output any unnecessary junk. Cron might mail it to someone. -if difference.size > 0 - puts difference +# Restore stdout, and print the header plus whatever the plugins +# produced if they produced anything. If they didn't, we avoid +# printing the header. +$stdout = STDOUT +if output_buffer.size > 0 then + puts make_header(plugin_class.to_s()) + puts output_buffer.string() end