X-Git-Url: http://gitweb.michael.orlitzky.com/?p=mailshears.git;a=blobdiff_plain;f=lib%2Fcommon%2Fpostfixadmin_plugin.rb;h=92b7a5b3036cdc8be3bba7df549d9d026cf8e87f;hp=b14f295031e4ff1178ec114ca483562604d394d4;hb=fa7782720ff15fce29b6f875678e9fd0c197485a;hpb=bf7d0402eda27d9487ca9402156818545fdda286 diff --git a/lib/common/postfixadmin_plugin.rb b/lib/common/postfixadmin_plugin.rb index b14f295..92b7a5b 100644 --- a/lib/common/postfixadmin_plugin.rb +++ b/lib/common/postfixadmin_plugin.rb @@ -1,146 +1,180 @@ +require 'common/domain' require 'common/plugin' +require 'common/user' require 'pg' +# Code that all Postfixadmin plugins ({PostfixadminPrune}, +# {PostfixadminRm}, {PostfixadminMv}) share. +# module PostfixadminPlugin - # Code that all Postfixadmin plugins (Prune, Rm, Mv...) will - # share. That is, we implement the Plugin interface. + + # We implement the Plugin "interface." include Plugin + # Initialize this Postfixadmin {Plugin} with values in *cfg*. + # + # @param cfg [Configuration] the configuration for this plugin. + # def initialize(cfg) - @db_host = cfg.postfixadmin_dbhost - @db_port = cfg.postfixadmin_dbport - @db_opts = cfg.postfixadmin_dbopts - @db_tty = cfg.postfixadmin_dbtty - @db_name = cfg.postfixadmin_dbname - @db_user = cfg.postfixadmin_dbuser - @db_pass = cfg.postfixadmin_dbpass - end - - - def describe_user(user) - # There's no other unique identifier in PostfixAdmin - return user - end - - - def describe_domain(domain) - # There's no other unique identifier in PostfixAdmin - return domain + @db_hash = { + :host => cfg.postfixadmin_dbhost, + :port => cfg.postfixadmin_dbport, + :options => cfg.postfixadmin_dbopts, + :tty => cfg.postfixadmin_dbtty, + :dbname => cfg.postfixadmin_dbname, + :user => cfg.postfixadmin_dbuser, + :password => cfg.postfixadmin_dbpass } end + # Obtain a list of domains from Postfixadmin. This is more efficient + # than the {Plugin} default implementation because domains have + # their own table in the database and we can easily select them + # rather than filtering the list of users. + # + # @return [Array] a list of the domains in Postfixadmin. + # def list_domains() domains = [] - # Just assume PostgreSQL for now. + connection = PG::Connection.new(@db_hash) + + # 'ALL' is a magic domain, and we don't want it. + sql_query = "SELECT domain FROM domain WHERE domain <> 'ALL';" + begin - connection = PGconn.connect(@db_host, - @db_port, - @db_opts, - @db_tty, - @db_name, - @db_user, - @db_pass) - - # 'ALL' is a magic domain, and we don't want it. - sql_query = "SELECT domain FROM domain WHERE domain <> 'ALL';" - connection.query(sql_query) do |result| + connection.sync_exec(sql_query) do |result| domains = result.field_values('domain') end + ensure + # Make sure the connection gets closed even if the query explodes. connection.close() - rescue PGError => e - # But pretend like we're database-agnostic in case we ever are. - raise DatabaseError.new(e) end - return domains + return domains.map{ |d| Domain.new(d) } end + # Return a list of Postfixadmin users. + # + # @return [Array] a list of users contained in the + # Postfixadmin database. + # def list_users() users = [] - # Just assume PostgreSQL for now. + connection = PG::Connection.new(@db_hash) + + sql_query = 'SELECT username FROM mailbox;' + begin - connection = PGconn.connect(@db_host, - @db_port, - @db_opts, - @db_tty, - @db_name, - @db_user, - @db_pass) - - sql_query = 'SELECT username FROM mailbox;' - connection.query(sql_query) do |result| + connection.sync_exec(sql_query) do |result| users = result.field_values('username') end + ensure + # Make sure the connection gets closed even if the query explodes. connection.close() - rescue PGError => e - # But pretend like we're database-agnostic in case we ever are. - raise DatabaseError.new(e) end - return users + return users.map{ |u| User.new(u) } end + + # Efficiently list all Postfixadmin users belonging to the given + # Postfixadmin *domains*. + # + # @param domains [Array] the domains whose users we want. + # + # @return [Array] a list of {User} objects belonging to + # *domains* for this plugin. + # def list_domains_users(domains) usernames = [] + return usernames if domains.length() == 0 - # Just assume PostgreSQL for now. - begin - connection = PGconn.connect(@db_host, - @db_port, - @db_opts, - @db_tty, - @db_name, - @db_user, - @db_pass) + connection = PG::Connection.new(@db_hash) - sql_query = 'SELECT username FROM mailbox WHERE domain IN $1;' + # The number of parameters that we'll pass into our prepared query + # is the number of domains that we're given. It's important that + # we have at least one domain here. + params = 1.upto(domains.length()).map{ |i| '$' + i.to_s() }.join(',') + sql_query = "SELECT username FROM mailbox WHERE domain IN (#{params});" - connection.query(sql_query, [domains]) do |result| + begin + # Now replace each Domain with its string representation and pass + # those in as our individual parameters. + connection.sync_exec_params(sql_query, domains.map{ |d| d.to_s() }) do |result| usernames = result.field_values('username') end - + ensure + # Make sure the connection gets closed even if the query explodes. connection.close() - rescue PGError => e - # Pretend like we're database-agnostic in case we ever are. - raise DatabaseError.new(e) end - return usernames + return usernames.map{ |u| User.new(u) } end + # Get a list of all Postfixadmin aliases as a from => to + # hash. This is useful for testing, since aliases should be removed + # when either the "from user" or "to user" are removed. + # + # @return [Hash] all aliases known to Postfixadmin in the form of a + # from => to hash. + # def list_aliases() - # - # Get a list of all aliases, useful for testing. - # aliases = [] - # Just assume PostgreSQL for now. + connection = PG::Connection.new(@db_hash) + + sql_query = 'SELECT address,goto FROM alias;' + begin - connection = PGconn.connect(@db_host, - @db_port, - @db_opts, - @db_tty, - @db_name, - @db_user, - @db_pass) - - sql_query = 'SELECT address,goto FROM alias;' - results = connection.query(sql_query) + results = connection.sync_exec(sql_query) results.each do |row| - aliases << row # row should be a hash + # row should be a hash + aliases << row end + ensure + # Make sure the connection gets closed even if the query explodes. connection.close() - rescue PGError => e - # But pretend like we're database-agnostic in case we ever are. - raise DatabaseError.new(e) end return aliases end + + # A fast implementation of the "does this domain exist?" + # operation. It only queries the database for the existence of + # *domain* rather than a list of all domains (which is the default + # implementation). + # + # @param domain [Domain] the domain whose existence is in question. + # + # @return [Boolean] true if *domain* exists in the Postfixadmin + # database and false otherwise. + # + def domain_exists(domain) + count = 0 + + connection = PG::Connection.new(@db_hash) + + sql_query = 'SELECT COUNT(domain) as count FROM domain WHERE domain = $1;' + + begin + connection.sync_exec_params(sql_query, [domain.to_s()]) do |result| + return false if result.ntuples() < 1 + count = result.getvalue(0,0).to_i() + + return false if count.nil? + end + ensure + # Make sure the connection gets closed even if the query explodes. + connection.close() + end + + return (count > 0) + end + end