postfix_admin 0.0.2 → 0.1.0

data/README.md

@@ -1,24 +1,34 @@
 # PostfixAdmin
 
-TODO: Write a gem description
+Command Line Tools of Postfix Admin
 
 ## Installation
 
-Add this line to your application's Gemfile:
-
-    gem 'postfix_admin'
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
+Install postfix_admin as:
 
     $ gem install postfix_admin
 
 ## Usage
 
-TODO: Write usage instructions here
+```
+  postfix_admin account_passwd user@example.com new_password    # Change password of account
+  postfix_admin add_account user@example.com password           # Add an account
+  postfix_admin add_admin admin@example.com password            # Add an admin user
+  postfix_admin add_admin_domain admin@example.com example.com  # Add admin_domain
+  postfix_admin add_alias alias@example.com goto@example.net    # Add an alias
+  postfix_admin add_domain example.com                          # Add a domain
+  postfix_admin admin_passwd admin@example.com new_password     # Change password of admin
+  postfix_admin delete_account user@example.com                 # Delete an account
+  postfix_admin delete_admin admin@example.com                  # Delete an admin
+  postfix_admin delete_alias alias@example.com                  # Delete an alias
+  postfix_admin delete_domain example.com                       # Delete a domain
+  postfix_admin help [TASK]                                     # Describe available tasks or one specific task
+  postfix_admin setup example.com password                      # Setup a domain
+  postfix_admin show                                            # List of domains
+  postfix_admin summary [example.com]                           # Summarize the usage of PostfixAdmin
+  postfix_admin super_admin admin@example.com                   # Enable super admin flag of an admin
+  postfix_admin version                                         # Show postfix_admin version
+```
 
 ## Contributing
 

data/Thorfile

@@ -0,0 +1,30 @@
+# encoding: utf-8
+$:.unshift File.expand_path("../lib", __FILE__)
+
+require 'bundler'
+require 'thor/rake_compat'
+
+class Default < Thor
+  include Thor::RakeCompat
+  Bundler::GemHelper.install_tasks
+
+  desc "build", "Build postfix_admin-#{PostfixAdmin::VERSION}.gem into the pkg directory"
+  def build
+    Rake::Task["build"].execute
+  end
+
+  desc "install", "Build and install postfix_admin-#{PostfixAdmin::VERSION}.gem into system gems"
+  def install
+    Rake::Task["install"].execute
+  end
+
+  desc "release", "Create tag v#{PostfixAdmin::VERSION} and build and push postfix_admin-#{PostfixAdmin::VERSION}.gem to Rubygems"
+  def release
+    Rake::Task["release"].execute
+  end
+
+  desc "spec", "Run RSpec code examples"
+  def spec
+    exec "rspec --color --format=documentation spec"
+  end
+end

data/bin/postfix_admin

@@ -1,101 +1,9 @@
 #!/usr/bin/env ruby
 
-require 'thor'
-require 'postfix_admin'
-require 'postfix_admin/cli'
+require 'postfix_admin/runner'
 
-class PostfixAdminCommand < Thor
-  def initialize(*args)
-    super
-    @cli = PostfixAdmin::CLI.new
-  end
-  desc "show", "List of domains"
-  def show(domain=nil)
-    if domain
-      @cli.show_domain_account(domain)
-    else
-      @cli.show_domain
-      @cli.show_admin
-    end
-  end
-
-  desc "add_domain", "add a domain"
-  def add_domain(domain=nil)
-    if domain
-      if @cli.add_domain(domain)
-        puts %Q!"#{domain}" is successfully registered.!
-      end
-      @cli.show_domain
-    else
-      puts "USAGE: #{$0} add_domain example.com"
-      exit
-    end
-  end
-
-  desc "delete_domain", "delete a domain"
-  def delete_domain(domain=nil)
-    if domain
-      if @cli.delete_domain(domain)
-        puts %Q!"#{domain}" is successfully deleted.!
-      end
-      @cli.show_domain
-    else
-      puts "USAGE: #{$0} delete_domain example.com"
-      exit
-    end
-  end
-
-  desc "add_account", "add an account"
-  def add_account(address=nil,password=nil)
-    if address && password
-      if @cli.add_account(address, password)
-        puts %Q!"#{address}" is successfully registered.!
-      end
-      @cli.show_domain_account(address.split(/@/)[1])
-    else
-      puts "USAGE: #{$0} add_account user@example.com password"
-      exit
-    end
-  end
-
-  desc "add_admin", "add an admin user"
-  def add_admin(user_name=nil, password=nil)
-    if user_name && password
-      if @cli.add_admin(user_name, password)
-      puts %Q!"#{user_name}" is successfully registered as admin.!
-      end
-      @cli.show_admin
-    else
-      puts "USAGE: #{$0} add_admin user@example.com password"
-      exit
-    end
-  end
-
-  desc "add_admin_domain", "add admin_domain"
-  def add_admin_domain(user_name=nil, domain=nil)
-    if user_name && domain
-      if @cli.add_admin_domain(user_name, domain)
-        puts %Q!"#{domain}" is appended in the domains of #{user_name}.!
-      end
-      @cli.show_admin_domain(user_name)
-    else
-      puts "USAGE: #{$0} add_admin_domain user@example.com example.com"
-      exit
-    end
-  end
-
-  desc "add_alias", "add an alias"
-  def add_alias(address=nil, goto=nil)
-    if address && goto
-      if @cli.add_alias(address, goto)
-        puts %Q!"#{address}: #{goto}" is successfully registered as alias.!
-      end
-      @cli.show_domain_account(address.split(/@/)[1])
-    else
-      puts "USAGE: #{$0} add_alias user@example.com goto@example.com"
-      exit
-    end
-  end
+begin
+  PostfixAdmin::Runner.start
+rescue => e
+  warn e.message
 end
-
-PostfixAdminCommand.start

data/lib/postfix_admin/base.rb

@@ -0,0 +1,188 @@
+require 'postfix_admin/models'
+require 'postfix_admin/error'
+
+require 'date'
+require 'data_mapper'
+
+module PostfixAdmin
+  class Base
+    attr_reader :config
+
+    DEFAULT_CONFIG = {
+      'database'  => 'mysql://postfix:password@localhost/postfix',
+      'aliases'   => 30,
+      'mailboxes' => 30,
+      'maxquota'  => 100
+    }
+
+    def initialize(config)
+      db_setup(config['database'])
+      @config = {}
+      @config[:aliases]   = config['aliases']   || 30
+      @config[:mailboxes] = config['mailboxes'] || 30
+      @config[:maxquota]  = config['maxquota']  || 100
+      @config[:mailbox_quota] = @config[:maxquota] * 1024 * 1000
+    end
+
+    def db_setup(database)
+      DataMapper.setup(:default, database)
+      DataMapper.finalize
+    end
+
+    def add_admin_domain(username, domain_name)
+      unless Admin.exist?(username)
+        raise Error, "#{username} is not resistered as admin."
+      end
+      unless Domain.exist?(domain_name)
+        raise Error, "Could not find domain #{domain_name}"
+      end
+
+      admin  = Admin.find(username)
+      if admin.has_domain?(domain_name)
+        raise Error, "#{username} is already resistered as admin of #{domain_name}."
+      end
+
+      domain = Domain.find(domain_name)
+      admin.domains << domain
+      admin.save or raise "Relation Error: Domain of Admin"
+    end
+
+    def add_admin(username, password)
+      if Admin.exist?(username)
+        raise Error, "#{username} is already resistered as admin."
+      end
+      admin = Admin.new
+      admin.attributes = {
+        :username => username,
+        :password => password,
+      }
+      admin.save or raise "Could not save Admin"
+    end
+
+    def add_account(address, password)
+      if address !~ /.+\@.+\..+/
+        raise Error, "Invalid mail address #{address}"
+      end
+      user, domain_name = address_split(address)
+      path = "#{domain_name}/#{address}/"
+
+      unless Domain.exist?(domain_name)
+        raise Error, "Could not find domain #{domain_name}"
+      end
+
+      if Alias.exist?(address)
+        raise Error, "#{address} is already resistered."
+      end
+
+      domain = Domain.find(domain_name)
+      mail_alias = Alias.new
+      mail_alias.attributes = {
+        :address     => address,
+        :goto        => address,
+      }
+      domain.aliases << mail_alias
+
+      mailbox = Mailbox.new
+      mailbox.attributes = {
+        :username => address,
+        :password => password,
+        :name     => '',
+        :maildir  => path,
+        :quota    => @config[:mailbox_quota],
+        # :local_part => user,
+      }
+      domain.mailboxes << mailbox
+      domain.save or raise "Could not save Domain"
+    end
+
+    def add_alias(address, goto)
+      if Mailbox.exist?(address)
+        raise Error, "mailbox #{address} is already registered!"
+      end
+      if Alias.exist?(address)
+        raise Error, "alias #{address} is already registered!"
+      end
+      user, domain_name = address_split(address)
+      unless Domain.exist?(domain_name)
+        raise Error, "Invalid domain! #{domain_name}"
+      end
+      domain = Domain.find(domain_name)
+
+      new_alias = Alias.new
+      new_alias.attributes = {
+        :address => address,
+        :goto    => goto,
+      }
+      domain.aliases << new_alias
+      domain.save or raise "Could not save Alias"
+    end
+
+    def delete_alias(address)
+      if Mailbox.exist?(address)
+        raise Error, "Can not delete mailbox by delete_alias. Use delete_account"
+      end
+      unless Alias.exist?(address)
+        raise Error, "#{address} is not found!"
+      end
+      Alias.all(:address => address).destroy or raise "Could not destroy Alias"
+    end
+
+    def add_domain(domain_name)
+      if domain_name !~ /.+\..+/
+        raise Error, "Ivalid domain! #{domain_name}"
+      end
+      if Domain.exist?(domain_name)
+        raise Error, "#{domain_name} is already registered!"
+      end
+      domain = Domain.new
+      domain.attributes = {
+        :domain_name  => domain_name,
+        :description  => domain_name,
+        :maxaliases   => @config[:aliases],
+        :maxmailboxes => @config[:mailboxes],
+        :maxquota     => @config[:maxquota],
+      }
+      domain.save or raise "Could not save Domain"
+    end
+
+    def delete_domain(domain_name)
+      unless Domain.exist?(domain_name)
+        raise Error, "Could not find domain #{domain_name}"
+      end
+
+      domain = Domain.find(domain_name)
+      domain.mailboxes.destroy or raise "Could not destroy Mailbox"
+      domain.aliases.destroy or raise "Could not destroy Alias"
+      domain.domain_admins.destroy or raise "Could not destroy DomainAdmin"
+      delete_unnecessary_admins
+
+      domain.destroy or raise "Could not destroy Domain"
+    end
+
+    def delete_admin(user_name)
+      unless Admin.exist?(user_name)
+        raise Error, "Could not find admin #{user_name}"
+      end
+      admin = Admin.find(user_name)
+      admin.domain_admins.destroy or raise "Could not destroy DomainAdmin"
+      admin.destroy or raise "Could not destroy Admin"
+    end
+
+    def delete_account(address)
+      unless Alias.exist?(address) && Mailbox.exist?(address)
+        raise Error, "Could not find account #{address}"
+      end
+
+      Mailbox.all(:username => address).destroy or raise "Could not destroy Mailbox"
+      Alias.all(:address => address).destroy or raise "Could not destroy Alias"
+    end
+
+    def delete_unnecessary_admins
+      Admin.unnecessary.destroy or raise "Could not destroy Admin"
+    end
+
+    def address_split(address)
+      address.split('@')
+    end
+  end
+end

data/lib/postfix_admin/cli.rb

@@ -1,123 +1,288 @@
 require 'yaml'
 require 'postfix_admin'
 
-class PostfixAdmin
+module PostfixAdmin
   class CLI
-    CONFIG_FILE = '.postfix_admin.conf'
+    CONFIG_FILE = '~/.postfix_admin.conf'
     MIN_NUM_PASSWORD_CHARACTER = 5
 
     def initialize
       @config = load_config
-      @admin = PostfixAdmin.new(@config)
+      @base = PostfixAdmin::Base.new(@config)
     end
-    # ~/.postfix_adminrc
-    # database: mysql://postfix:password@localhost/postfix
-    # aliases: 30
-    # mailboxes: 30
-    # maxquota: 100
-    def load_config
-      unless File.exist?(config_file)
-        create_config
-        puts "configure file: #{config_file} was generated.\nPlease execute after edit it."
-        exit
+
+    def show(domain)
+      show_summary(domain)
+
+      if domain
+        show_admin(domain)
+        show_address(domain)
+        show_alias(domain)
+      else
+        show_domain
+        show_admin
       end
-      open(config_file) do |f|
-        YAML.load(f.read)
+    end
+
+    def show_summary(domain_name=nil)
+      title = "Summary"
+      if domain_name
+        domain_check(domain_name)
+        title = "Summary of #{domain_name}"
+      end
+
+      report(title) do
+        if domain_name
+          domain = Domain.find(domain_name)
+          puts "Mailboxes : %4d"    % domain.mailboxes.count
+          puts "Aliases   : %4d"    % domain.num_total_aliases
+          puts "Quota     : %4d MB" % domain.maxquota
+        else
+          puts "Domains   : %4d" % Domain.all_without_special_domain.count
+          puts "Admins    : %4d" % Admin.count
+          puts "Mailboxes : %4d" % Mailbox.count
+          puts "Aliases   : %4d" % Domain.num_total_aliases
+        end
       end
     end
-    def create_config
-      config = {
-        'database'  => 'mysql://postfix:password@localhost/postfix',
-        'aliases'   => 30,
-        'mailboxes' => 30,
-        'maxquota'  => 100
-      }
-      open(config_file, 'w') do |f|
-        f.write config.to_yaml
+
+    def setup_domain(domain, password)
+      admin = "admin@#{domain}"
+      add_domain(domain)
+      add_admin(admin, password)
+      add_admin_domain(admin, domain)
+    end
+
+    def show_domain
+      index = " No. Domain                Aliases   Mailboxes     Quota (MB)"
+      report('Domains', index) do
+        if Domain.all_without_special_domain.count == 0
+          puts " No domains"
+        else
+          Domain.all_without_special_domain.each_with_index do |d, i|
+            puts "%4d %-20s %3d /%3d   %3d /%3d %10d" %
+              [i+1, d.domain_name, d.num_total_aliases, d.maxaliases,
+               d.mailboxes.count, d.maxmailboxes, d.maxquota]
+          end
+        end
       end
-      File.chmod(0600, config_file)
     end
-    def config_file
-      File.expand_path(CONFIG_FILE, ENV['HOME'])
+
+    def add_domain(domain)
+      if @base.add_domain(domain)
+        puts %Q!"#{domain}" was successfully registered.!
+      end
     end
-    def print_line
-      puts "-"*85
+
+    def super_admin(user_name, disable)
+      unless Admin.exist?(user_name)
+        raise Error, "Could not find admin #{user_name}"
+      end
+
+      if disable
+        Admin.find(user_name).super_admin = false
+        puts "Successfully disabled super admin flag of #{user_name}"
+      else
+        Admin.find(user_name).super_admin = true
+        puts "Successfully enabled super admin flag of #{user_name}"
+      end
     end
-    def show_domain
-      print_line
-      puts " No.   domain             alias mail quota"
-      print_line
-      @admin.domains.each_with_index do |domain, i|
-        printf("%4d %-20s %4d %4d %4d\n", i+1, domain.domain, domain.aliases, domain.mailboxes, domain.maxquota)
+
+    def change_admin_password(user_name, password)
+      change_password(Admin, user_name, password)
+    end
+
+    def change_account_password(user_name, password)
+      change_password(Mailbox, user_name, password)
+    end
+
+    def delete_domain(domain)
+      if @base.delete_domain(domain)
+        puts_deleted(domain)
       end
-      print_line
     end
-    def show_admin
-      admins = @admin.admins
-      if admins.count == 0
-        puts "No admin in database\n"
-        return
+
+    def show_admin(domain=nil)
+      admins = domain ? Admin.select{|a| a.has_domain?(domain)} : Admin.all
+      index = " No. Admin                              Domains Password"
+      report("Admins", index) do
+        if admins.count == 0
+          puts " No admins"
+        else
+          admins.each_with_index do |a, i|
+            domains = a.super_admin? ? 'Super admin' : a.domains.count
+            puts "%4d %-30s %11s %s" % [i+1, a.username, domains, a.password]
+          end
+        end
       end
-      print_line
-      puts " No.   username           password"
-      print_line
-      admins.each_with_index do |admin, i|
-        printf("%4d %-20s %10s\n", i+1, admin.username, admin.password)
+
+    end
+
+    def show_address(domain)
+      domain_check(domain)
+
+      mailboxes = Domain.find(domain).mailboxes
+      index = " No. Email                           Quota (MB) Password"
+      report("Addresses", index) do
+        if mailboxes.count == 0
+          puts " No addresses"
+        else
+          mailboxes.each_with_index do |m, i|
+            quota = m.quota.to_f/1024000.0
+            puts "%4d %-30s  %10.1f %s" % [i+1, m.username, quota, m.password]
+          end
+        end
       end
-      print_line
+
     end
-    def show_domain_account(domain)
-      mailboxes = @admin.mailboxes(domain)
-      if mailboxes.count == 0
-        puts "No address in #{domain}\n"
-        return
+
+    def show_alias(domain)
+      domain_check(domain)
+
+      aliases = Domain.find(domain).aliases.find_all do |mail_alias|
+        mail_alias.address != mail_alias.goto
       end
-      print_line
-      puts " No.   address             password  quota(M) maildir"
-      print_line
-      mailboxes.each_with_index do |mailbox, i|
-        printf("%4d %-20s %10s %7.1f  %-30s\n", i+1, mailbox.username, mailbox.password, mailbox.quota.to_f/1024000.0, mailbox.maildir)
+
+      index = " No. Address                        Go to"
+      report("Aliases", index) do
+        if aliases.count == 0
+          puts " No aliases"
+        else
+          aliases.each_with_index do |a, i|
+            puts "%4d %-30s %s" % [i+1, a.address, a.goto]
+          end
+        end
       end
-      print_line
+
     end
+
     def show_admin_domain(user_name)
-      domain_admins = @admin.admin_domains(user_name)
-      if domain_admins.count == 0
-        puts "No domain in database\n"
+      admin = Admin.find(user_name)
+      if admin.domains.count == 0
+        puts "\nNo domain in database"
         return
       end
-      print_line
-      puts " No.   domain"
-      print_line
-      domain_admins.each_with_index do |domain_admin, i|
-        printf("%4d %-20s\n", i+1, domain_admin.domain)
+      report("Domains (#{user_name})", " No. Domain") do
+        admin.domains.each_with_index do |d, i|
+          puts "%4d %-20s" % [i+1, d.domain_name]
+        end
       end
-      print_line
     end
-    def add_domain(domain)
-      @admin.add_domain(domain)
-    end
-    def add_admin(user_name, password)
+
+    def add_admin(user_name, password, super_admin=false)
       validate_password(password)
-      @admin.add_admin(user_name, password)
+      if @base.add_admin(user_name, password)
+        if super_admin
+          Admin.find(user_name).super_admin = true
+          puts_registered(user_name, "a super admin")
+        else
+          puts_registered(user_name, "an admin")
+        end
+      end
+    end
+
+    def add_admin_domain(user_name, domain)
+      if @base.add_admin_domain(user_name, domain)
+        puts_registered(domain, "a domain of #{user_name}")
+      end
     end
+
     def add_account(address, password)
       validate_password(password)
-      @admin.add_account(address, password)
+      if @base.add_account(address, password)
+        puts_registered(address, "an account")
+      end
     end
+
     def add_alias(address, goto)
-      @admin.add_alias(address, goto)
+      if @base.add_alias(address, goto)
+        puts_registered("#{address}: #{goto}", "an alias")
+      end
     end
-    def add_admin_domain(user_name, domain)
-      @admin.add_admin_domain(user_name, domain)
+
+    def delete_alias(address)
+      puts_deleted(address) if @base.delete_alias(address)
     end
-    def delete_domain(domain)
-      @admin.delete_domain(domain)
+
+    def delete_admin(user_name)
+      puts_deleted(user_name) if @base.delete_admin(user_name)
+    end
+
+    def delete_account(address)
+      puts_deleted(address) if @base.delete_account(address)
+    end
+
+    private
+
+    def puts_registered(name, as_str)
+      puts %Q!"#{name}" was successfully registered as #{as_str}.!
+    end
+
+    def puts_deleted(name)
+      puts %Q!"#{name}" was successfully deleted.!
     end
+
+    def config_file
+      config_file = File.expand_path(CONFIG_FILE)
+    end
+
+    def load_config
+      unless File.exist?(config_file)
+        create_config(config_file)
+        puts "configure file: #{config_file} was generated.\nPlease execute after edit it."
+        exit
+      end
+      open(config_file) do |f|
+        YAML.load(f.read)
+      end
+    end
+
+    def create_config(config_file)
+      open(config_file, 'w') do |f|
+        f.write PostfixAdmin::Base::DEFAULT_CONFIG.to_yaml
+      end
+      File.chmod(0600, config_file)
+    end
+
+    def print_line
+      puts "-"*100
+    end
+
+    def report(title, index=nil)
+      puts "\n[#{title}]"
+      print_line if index
+      puts index if index
+      print_line
+      yield
+      print_line
+    end
+
+    def domain_check(domain_name)
+      unless Domain.exist?(domain_name)
+        raise Error, %Q!Could not find domain "#{domain_name}"!
+      end
+    end
+
     def validate_password(password)
       if password.size < MIN_NUM_PASSWORD_CHARACTER
-        raise "Error: Password is too short. It should be larger than #{MIN_NUM_PASSWORD_CHARACTER}"
+        raise ArgumentError, "Password is too short. It should be larger than #{MIN_NUM_PASSWORD_CHARACTER}"
       end
     end
+
+    def change_password(klass, user_name, password)
+      unless klass.exist?(user_name)
+        raise Error, "Could not find #{user_name}"
+      end
+      validate_password(password)
+
+      obj = klass.find(user_name)
+      obj.password = password
+      if obj.save
+        puts "the password of #{user_name} was successfully changed."
+      else
+        raise "Could not change password of #{klass.name}"
+      end
+    end
+
   end
 end