postdb 0.1.5

data/lib/postdb/cli/domains/dkim.rb

@@ -0,0 +1,69 @@
+module PostDB
+  module CLI
+    class Domains < Thor
+      class DKIM < Thor
+        no_tasks do
+          include PostDB::CLI::Helper
+        end
+
+        desc "dns DOMAIN", "Get the DNS record for a domain's DKIM key"
+        def dns(domain_name = nil)
+          unless domain_name
+            domains = PostDB::Domain.all
+
+            if domains.empty?
+              exit_with_warning("There don't appear to be any domains on this system.")
+            end
+
+            domain_name = prompt.select("Domain:", domains.map(&:name))
+          end
+
+          domain_name = domain_name.downcase
+
+          domain = PostDB::Domain.where(name: domain_name).first
+
+          dkim_public = [domain.dkim.public_key.to_der].pack('m').gsub("\n", '')
+
+          puts "mail._domainkey.#{domain.name}:"
+          puts " v=DKIM1; k=rsa; p=#{dkim_public};"
+        end
+
+        desc "regenerate DOMAIN", "Regenerate the DKIM key for a domain"
+        option :force, type: :boolean, default: false
+        def regenerate(domain_name = nil)
+          unless domain_name
+            domains = PostDB::Domain.all
+
+            if domains.empty?
+              exit_with_warning("There don't appear to be any domains on this system.")
+            end
+
+            domain_name = prompt.select("Domain:", domains.map(&:name))
+          end
+
+          domain_name = domain_name.downcase
+
+          domains = PostDB::Domain.where(name: domain_name)
+
+          if domains.empty?
+            exit_with_warning("The domain '#{domain_name}' could not be found.")
+          end
+
+          unless options[:force]
+            confirm_action!("Regenerate the DKIM key for '#{domain_name}'?", "'#{domain_name}' left untouched.")
+          end
+
+          domains.each do |domain|
+            domain.regenerate_dkim
+
+            unless domain.save
+              exit_with_error("The DKIM key for '#{domain_name}' couldn't be regenerated.")
+            end
+          end
+
+          prompt.ok("The DKIM key for '#{domain_name}' has been regenerated.")
+        end
+      end
+    end
+  end
+end

data/lib/postdb/cli/helper.rb

@@ -0,0 +1,101 @@
+module PostDB
+	module CLI
+    # The helper CLI module
+    #
+    # This module contains helper functionality for the CLI.
+    #
+		module Helper
+			# Print a newline character
+			#
+			# Example:
+			#   >> new_line
+			#   => "\n"
+			#
+			def new_line
+				puts ""
+			end
+
+			# Get a prompt object
+			#
+			# Example:
+			#   >> prompt
+			#   => #<TTY::Prompt:0x00000000000000>
+			#
+			def prompt
+				@prompt ||= TTY::Prompt.new
+			end
+
+			# Exit with an error
+			#
+			# Arguments:
+			#   messages: (Splat)
+			#
+			# Example:
+			#   >> exit_with_error "Oops!"
+			#   => nil
+			#
+			def exit_with_error(*messages)
+				messages.each do |message|
+					("\n" == message) ? print(message) : prompt.error(message)
+				end
+
+				exit 1
+			end
+
+			# Exit with a warning
+			#
+			# Arguments:
+			#   messages: (Splat)
+			#
+			# Example:
+			#   >> exit_with_warning "Oops!"
+			#   => nil
+			#
+			def exit_with_warning(*messages)
+				messages.each do |message|
+					("\n" == message) ? print(message) : prompt.warn(message)
+				end
+
+				exit 1
+			end
+
+			# Confirm an action
+			#
+			# Arguments:
+			#   message: (String)
+			#   aborted_message: (String)
+			#
+			# Example:
+			#   >> confirm_action! "Do something?"
+			#   => nil
+			#
+			def confirm_action!(message, aborted_message = nil)
+				# Prompt the user to confirm the action
+				if prompt.no?(message)
+					# Exit with a warning
+					exit_with_warning(aborted_message)
+				end
+			end
+
+			# Format an error
+			#
+			# Arguments:
+			#   error: (Exception)
+			#
+			# Example:
+			#   >> format_error(error)
+			#   => ["\n", "Error:", "  Error Message", "Backtrace:", "  from (irb):1"]
+			#
+			def format_error(error)
+				errors = Array.new
+				errors << "\n"
+				errors << "Error:"
+				errors << "  " + error.message
+				errors << "\n"
+				errors << "Backtrace:"
+				errors += error.backtrace.map { |trace| "  " + trace }
+				errors
+			end
+		end
+	end
+end

data/lib/postdb/cli/main.rb

@@ -0,0 +1,44 @@
+module PostDB
+  module CLI
+    # The main CLI class
+    #
+    # This class contains the core CLI functionality.
+    #
+    class Main < Thor
+      class_option :configuration_file, type: :string, aliases: :c, default: '/etc/postdb/postdb.yml'
+      class_option :verbose, type: :boolean, aliases: :v, default: false
+
+      no_tasks do
+        include PostDB::CLI::Helper
+
+        def initialize(*args, &block)
+          super(*args, &block)
+
+          configuration_file = options[:configuration_file]
+
+          unless File.file?(configuration_file)
+            exit_with_error("The configuration file '#{configuration_file}' is missing.")
+          end
+
+          begin
+            PostDB.setup(configuration_file)
+          rescue PostDB::SetupError => e
+            exit_with_error(e.message)
+          end
+        end
+      end
+
+      desc "domains SUBCOMMAND ...ARGS", "Manage the domains"
+      subcommand "domains", PostDB::CLI::Domains
+
+      desc "users SUBCOMMAND ...ARGS", "Manage the users"
+      subcommand "users", PostDB::CLI::Users
+
+      desc "aliases SUBCOMMAND ...ARGS", "Manage the aliases"
+      subcommand "aliases", PostDB::CLI::Aliases
+
+      desc "database SUBCOMMAND ...ARGS", "Manage the database"
+      subcommand "database", PostDB::CLI::Database
+    end
+  end
+end

data/lib/postdb/cli/users.rb

@@ -0,0 +1,146 @@
+module PostDB
+  module CLI
+    class Users < Thor
+      no_tasks do
+        include PostDB::CLI::Helper
+
+        def get_password_or_ask
+          password = options[:password]
+
+          unless password
+            password = prompt.mask("Password:") do |q|
+              q.required(true)
+            end
+
+            password_confirmation = prompt.mask("Password Confirmation:") do |q|
+              q.required(true)
+            end
+
+            unless password == password_confirmation
+              exit_with_error("Those passwords don't match.")
+            end
+          end
+
+          password
+        end
+      end
+
+      desc "list DOMAIN", "List all users"
+      def list(domain = nil)
+        domains = PostDB::Domain.where(**(domain ? { name: domain } : {}))
+
+        if domains.empty?
+          if domain
+            exit_with_warning("The domain '#{domain}' could not be found.")
+          else
+            exit_with_warning("There don't appear to be any domains on this system.")
+          end
+        end
+
+        domains.each_with_index do |domain, index|
+          users = domain.users.sort { |a, b| a.email <=> b.email }
+
+          puts TTY::Table.new(
+            header: [domain.name].pad(' '),
+            rows: users.empty? ? [[' No Users ']] : users.map { |u| [u.email].pad(' ') }
+          ).render(:ascii)
+
+          new_line unless (index + 1) == domains.count
+        end
+      end
+
+      desc "add EMAIL", "Add a user"
+      option :password, type: :string, default: nil, aliases: :p
+      def add(email = nil)
+        unless email
+          email = prompt.ask("Email:") do |q|
+            q.required(true)
+            q.validate(:email)
+          end
+        end
+
+        email = email.downcase
+
+        if PostDB::User.where(email: email).count > 0
+          exit_with_warning("The user '#{email}' has already been added.")
+        end
+
+        domain_name = email.split('@')[1]
+
+        unless domain = PostDB::Domain.where(name: domain_name).first
+          exit_with_error("The domain '#{domain_name}' is not available.")
+        end
+
+        password = get_password_or_ask
+
+        PostDB::User.create(domain: domain, email: email, password: password)
+
+        prompt.ok("The user '#{email}' has been added.")
+      end
+
+      desc "remove EMAIL", "Remove a user"
+      option :force, type: :boolean, default: false
+      def remove(email = nil)
+        unless email
+          users = PostDB::User.all
+
+          if users.empty?
+            exit_with_warning("There don't appear to be any users on this system.")
+          end
+
+          email = prompt.select("User:", users.map(&:email))
+        end
+
+        email = email.downcase
+
+        users = PostDB::User.where(email: email)
+
+        if users.empty?
+          exit_with_warning("The user '#{email}' could not be found.")
+        end
+
+        unless options[:force]
+          confirm_action!("Remove the user '#{email}'?", "'#{email}' left untouched.")
+        end
+
+        users.each(&:destroy)
+
+        prompt.ok("The user '#{email}' has been removed.")
+      end
+
+      desc "change_password", "Change a user's password"
+      option :password, type: :string, default: nil, aliases: :p
+      def change_password(email = nil)
+        unless email
+          users = PostDB::User.all
+
+          if users.empty?
+            exit_with_warning("There don't appear to be any users on this system.")
+          end
+
+          email = prompt.select("User:", users.map(&:email))
+        end
+
+        email = email.downcase
+
+        users = PostDB::User.where(email: email)
+
+        if users.empty?
+          exit_with_warning("The user '#{email}' could not be found.")
+        end
+
+        password = get_password_or_ask
+
+        users.each do |user|
+          user.update(password: password)
+        end
+
+        prompt.ok("The password for '#{email}' has been changed.")
+      end
+
+      map changepw: :change_password
+
+      default_task :list
+    end
+  end
+end

data/lib/postdb/configuration.rb

@@ -0,0 +1,35 @@
+module PostDB
+  class Configuration
+    class << self
+      # Load the configuration from a file
+      #
+      # Arguments:
+      #   path: (String) The path to the configuration file
+      #
+      # Example:
+      #   >> PostDB::Configuration.load_file(path)
+      #   => true
+      #
+      def load_file(path)
+        @configuration = YAML.load(File.read(path))
+
+        true
+      end
+
+      # Get a value from the configuration
+      #
+      # Arguments:
+      #   name: (String)
+      #
+      # Example:
+      #   >> PostDB::Configuration[:database]
+      #   => { ... }
+      #
+      def [](name)
+        return nil unless @configuration
+
+        @configuration[name]
+      end
+    end
+  end
+end

data/lib/postdb/constants.rb

@@ -0,0 +1,3 @@
+module PostDB
+  VERSION = '0.1.5'
+end

data/lib/postdb/database.rb

@@ -0,0 +1,23 @@
+module PostDB
+  class Database
+    class << self
+      # Setup the database
+      #
+      # Example:
+      #   >> PostDB::Database.setup_with_configuration!
+      #   => nil
+      #
+      def setup_with_configuration!
+        configuration = PostDB::Configuration[:database]
+
+        unless configuration.is_a?(Hash)
+          raise PostDB::SetupError.new(:missing_database_args)
+        end
+
+        ActiveRecord::Base.establish_connection(**configuration)
+
+        nil
+      end
+    end
+  end
+end

data/lib/postdb/dkim.rb

@@ -0,0 +1,197 @@
+module PostDB
+  class DKIM
+    class << self
+      # The path to the directory where DKIM keys are stored
+      #
+      attr_reader :keys_directory
+
+      # The path to the trusted hosts file
+      #
+      attr_reader :trusted_hosts_path
+
+      # The path to the key table file
+      #
+      attr_reader :key_table_path
+
+      # The path to the signing table file
+      #
+      attr_reader :signing_table_path
+
+      # Setup the DKIM configuration
+      #
+      # Example:
+      #   >> PostDB::DKIM.setup_with_configuration!
+      #   => nil
+      #
+      def setup_with_configuration!
+        configuration = PostDB::Configuration[:dkim]
+
+        unless configuration.is_a?(Hash)
+          raise PostDB::SetupError.new(:missing_dkim_args)
+        end
+
+        unless configuration[:directory]
+          raise PostDB::SetupError.new(:missing_dkim_directory)
+        end
+
+        unless configuration[:trusted_hosts_path]
+          raise PostDB::SetupError.new(:missing_trusted_hosts_path)
+        end
+
+        unless configuration[:key_table_path]
+          raise PostDB::SetupError.new(:missing_key_table_path)
+        end
+
+        unless configuration[:signing_table_path]
+          raise PostDB::SetupError.new(:missing_signing_table_path)
+        end
+
+        @keys_directory = configuration[:directory]
+
+        unless File.directory?(@keys_directory)
+          FileUtils.mkdir_p(@keys_directory)
+        end
+
+        @trusted_hosts_path = configuration[:trusted_hosts_path]
+        @key_table_path = configuration[:key_table_path]
+        @signing_table_path = configuration[:signing_table_path]
+
+        true
+      end
+
+      # Generate the OpenDKIM configuration files
+      #
+      # Example:
+      #   >> PostDB::DKIM.generate_configuration
+      #   => nil
+      #
+      def generate_configuration
+        dump_private_keys
+        generate_trusted_hosts_configuration
+        generate_key_table_configuration
+        generate_signing_table_configuration
+        restart_opendkim
+
+        nil
+      end
+
+      private
+      # Get the passwd object for the opendkim user
+      #
+      # Example:
+      #   >> PostDB::DKIM.passwd
+      #   => #<struct Etc::Passwd name="opendkim", passwd="x", uid=101, gid=101, gecos="", dir="/var/run/opendkim", shell="/bin/false">
+      #
+      def passwd
+        Etc.passwd do |passwd|
+          next unless passwd.name == 'opendkim'
+
+          return passwd
+        end
+
+        nil
+      end
+
+      # Dump the private keys for each domain
+      #
+      # Example:
+      #   >> PostDB::DKIM.dump_private_keys
+      #   => nil
+      #
+      def dump_private_keys
+        domains = PostDB::Domain.all
+
+        dkim_keys = domains.map { |domain| File.basename(domain.dkim_path) }
+
+        keys_directory_glob = File.join(@keys_directory, '**', '*')
+
+        Dir.glob(keys_directory_glob).each do |key|
+          next if dkim_keys.include?(File.basename(key))
+
+          FileUtils.rm_f(key)
+        end
+
+        domains.each do |domain|
+          File.open(domain.dkim_path, 'w') do |file|
+            file.write(domain.dkim.to_pem)
+          end
+
+          next unless passwd
+
+          File.chown(passwd.uid, passwd.gid, domain.dkim_path)
+          File.chmod(0600, domain.dkim_path)
+        end
+
+        nil
+      end
+
+      # Generate the TrustedHosts configuration file
+      #
+      # Example:
+      #   >> PostDB::DKIM.generate_trusted_hosts_configuration
+      #   => nil
+      #
+      def generate_trusted_hosts_configuration
+        trusted_hosts = ['127.0.0.1', 'localhost']
+        trusted_hosts += PostDB::Domain.all.map { |domain| "*." + domain.name }
+
+        File.open(@trusted_hosts_path, 'w') do |file|
+          file.write(trusted_hosts.join("\n"))
+        end
+
+        nil
+      end
+
+      # Generate the KeyTable configuration file
+      #
+      # Example:
+      #   >> PostDB::DKIM.generate_key_table_configuration
+      #   => nil
+      #
+      def generate_key_table_configuration
+        selector = "mail"
+
+        key_table = Array.new
+        key_table += PostDB::Domain.all.map { |domain| selector + "._domainkey." + domain.name + " " + domain.name + ":" + selector + ":" + domain.dkim_path }
+
+        File.open(@key_table_path, 'w') do |file|
+          file.write(key_table.join("\n"))
+        end
+
+        nil
+      end
+
+      # Generate the SigningTable configuration file
+      #
+      # Example:
+      #   >> PostDB::DKIM.generate_signing_table_configuration
+      #   => nil
+      #
+      def generate_signing_table_configuration
+        selector = "mail"
+
+        signing_table = Array.new
+        signing_table += PostDB::Domain.all.map { |domain| "*@" + domain.name + " " + selector + "._domainkey." + domain.name }
+
+        File.open(@signing_table_path, 'w') do |file|
+          file.write(signing_table.join("\n"))
+        end
+
+        nil
+      end
+
+      # Restart the OpenDKIM daemon
+      #
+      # Example:
+      #   >> PostDB::DKIM.restart_opendkim
+      #   => true
+      #
+      def restart_opendkim
+        return false unless system("service opendkim stop > /dev/null 2>&1")
+        return false unless system("service opendkim start > /dev/null 2>&1")
+
+        true
+      end
+    end
+  end
+end