postfix_admin 0.1.0 → 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a83f945f0f977fc80b8715b899af26d908b3d6b1169d27fae9cf92089bac5082
+  data.tar.gz: f8f63116ece1064079b99f986fc26778c4f4affc28ae8dbd3beca3496a595186
+SHA512:
+  metadata.gz: 22f7cc6d351d3a7e63ba95e653ac21f4b1eeebaebb5a717810477ab0d700dbb3199eeee042ca34909aee1c959bb7d27fe705d1c332895e7bb38ae0cc1f3e9120
+  data.tar.gz: 821bb8bac75277e3faf303f1db8292256cc9bbcf40cb2de6f63f9c3c38e40f84c5739849edc159ddec8bf262d9fa9e5ea8f9bac15e8dce37f2691f0a017e2772

data/.gitignore

@@ -15,3 +15,5 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+.idea
+.vagrant

data/.rubocop.yml

@@ -0,0 +1,2 @@
+Style/StringLiterals:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,18 @@
+## 0.2.0
+ * Switched its object-relational mapper from DataMapper to ActiveRecord
+ * Stored password hash includes scheme prefix: like `{CRAM-MD5}`, `{PLAIN}`
+
+## 0.1.4
+ * Added "log" subcommand
+
+## 0.1.3
+ * Support for activation and deactivation of domain, admin and account
+ * Added "edit_admin" subcommand
+
+## 0.1.2
+ * Support password hash by doveadm (external subcommand)
+ * Show active status
+ * Don't show passwords using list format
+
+## 0.1.1, release 2013-05-10
+ * Fixed string length of password

data/Dockerfile

@@ -0,0 +1,24 @@
+FROM centos:8
+
+RUN dnf -y module enable ruby:2.6 \
+    && dnf -y install \
+    ruby ruby-devel mariadb-devel sqlite-devel gcc make redhat-rpm-config \
+    mariadb dovecot git \
+    && dnf clean all
+
+WORKDIR /app
+
+COPY Gemfile postfix_admin.gemspec ./
+COPY ./lib/postfix_admin/version.rb ./lib/postfix_admin/version.rb
+
+RUN gem install bundler && bundle install
+
+COPY spec/postfix_admin.conf /root/.postfix_admin.conf
+
+COPY docker-entrypoint.sh /docker-entrypoint.sh
+RUN chmod +x /docker-entrypoint.sh
+ENTRYPOINT ["/docker-entrypoint.sh"]
+
+EXPOSE 80
+
+CMD ["/sbin/init"]

data/README.md

@@ -1,6 +1,20 @@
-# PostfixAdmin
+[![Gem Version](https://badge.fury.io/rb/postfix_admin.png)](https://rubygems.org/gems/postfix_admin)
 
-Command Line Tools of Postfix Admin
+# postfix_admin
+
+Command Line Tools for Postfix Admin
+
+## Description
+
+* Postfix Admin (Original Web-based Application)
+  + Web Site http://postfixadmin.sourceforge.net/
+  + GitHub https://github.com/postfixadmin/postfixadmin
+
+* Postfix Admin 3.2 is supported.
+
+* MySQL/MariaDB is supported.
+
+* Other database engines are not supported.
 
 ## Installation
 
@@ -8,32 +22,48 @@ Install postfix_admin as:
 
     $ gem install postfix_admin
 
+Just execute `postfix_admin` command to generate your config file: `~/.postfix_admin.conf`
+
+    $ postfix_admin
+
+Edit the file for your environment:
+
+    $ vi ~/.postfix_admin.conf
+
+You can see domains on your host if the `database` parameter is set properly:
+
+    $ postfix_admin show
+
 ## Usage
 
-```
-  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
-```
+List the postfix_admin subcommands as:
 
-## Contributing
+    $ postfix_admin
 
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Added some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+```
+Commands:
+  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_admin_domain admin@example.com example.com          # Delete admin_domain
+  postfix_admin delete_alias alias@example.com                             # Delete an alias
+  postfix_admin delete_domain example.com                                  # Delete a domain
+  postfix_admin dump                                                       # Dump all data
+  postfix_admin edit_account user@example.com                              # Edit an account
+  postfix_admin edit_admin admin@example.com                               # Edit an admin user
+  postfix_admin edit_alias alias@example.com                               # Edit an alias
+  postfix_admin edit_domain example.com                                    # Edit a domain limitation
+  postfix_admin help [COMMAND]                                             # Describe available commands or one specific command
+  postfix_admin log                                                        # Show action logs
+  postfix_admin schemes                                                    # List all supported password schemes
+  postfix_admin setup example.com password                                 # Setup a domain
+  postfix_admin show [example.com | admin@example.com | user@example.com]  # Show domains or admins or mailboxes
+  postfix_admin summary [example.com]                                      # Summarize the usage of PostfixAdmin
+  postfix_admin version                                                    # Show postfix_admin version
+```

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "postfix_admin"
+require "postfix_admin/cli"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+cli = PostfixAdmin::CLI.new
+cli.db_setup
+include PostfixAdmin
+
+require "pry"
+Pry.start
+
+# require "irb"
+# IRB.start(__FILE__)

data/docker-compose.yml

@@ -0,0 +1,24 @@
+version: '3.8'
+
+services:
+  app:
+    build: .
+    tty: true
+    ports:
+    - '7080:80'
+    volumes:
+    - .:/app
+    - /sys/fs/cgroup:/sys/fs/cgroup:ro
+    tmpfs:
+      - /tmp
+      - /run
+    stop_signal: SIGRTMIN+3
+  db:
+    image: mariadb:10
+    volumes:
+    - ./spec/postfix.v1841.sql:/docker-entrypoint-initdb.d/postfix.sql
+    environment:
+      - MYSQL_RANDOM_ROOT_PASSWORD=yes
+      - MYSQL_USER=postfix
+      - MYSQL_PASSWORD=password
+      - MYSQL_DATABASE=postfix

data/docker-entrypoint.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+set -eu
+
+exec "$@"

data/exe/postfix_admin

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << File.expand_path(File.dirname(__FILE__) + "/../lib")
+require 'postfix_admin/runner'
+
+PostfixAdmin::Runner.start

data/lib/postfix_admin.rb

@@ -1,2 +1,6 @@
 require "postfix_admin/version"
 require "postfix_admin/base"
+
+module PostfixAdmin
+  KB_TO_MB = 1_024_000
+end

data/lib/postfix_admin/admin.rb

@@ -0,0 +1,52 @@
+require 'postfix_admin/concerns/dovecot_cram_md5_password'
+
+module PostfixAdmin
+  class Admin < ApplicationRecord
+    self.table_name = :admin
+    self.primary_key = :username
+
+    include DovecotCramMD5Password
+
+    validates :username, presence: true, uniqueness: { case_sensitive: false },
+                         format: { with: RE_EMAIL_LIKE_WITH_ANCHORS,
+                                   message: "must be a valid email address" }
+
+    has_many :domain_admins, foreign_key: :username, dependent: :delete_all
+    has_many :rel_domains, through: :domain_admins
+
+    attr_accessor :domain_ids
+    attribute :form_super_admin, :boolean, default: false
+
+    # just in case
+    validate on: :update do |admin|
+      admin.errors.add(:username, 'cannot be changed') if admin.username_changed?
+    end
+
+    def super_admin?
+      if @super_admin.nil?
+        @super_admin = rel_domains.exists?("ALL")
+      else
+        @super_admin
+      end
+    end
+
+    def super_admin=(value)
+      if value
+        domain_ids = self.rel_domain_ids.dup
+        domain_ids << "ALL"
+        self.rel_domain_ids = domain_ids
+        save!
+      else
+        domain_admins.where(domain: "ALL").delete_all
+      end
+    end
+
+    def has_admin?(admin)
+      self == admin || super_admin?
+    end
+
+    def has_domain?(domain)
+      !rel_domains.where(domain: ["ALL", domain.domain]).empty?
+    end
+  end
+end

data/lib/postfix_admin/alias.rb

@@ -0,0 +1,65 @@
+module PostfixAdmin
+  class Alias < ApplicationRecord
+    self.table_name = :alias
+    self.primary_key = :address
+
+    validate on: :create do |a|
+      domain = a.rel_domain
+      if domain.aliases.zero? || a.mailbox
+      elsif domain.rel_aliases.pure.count >= domain.aliases
+        message = "already has the maximum number of aliases " \
+                  "(maximum is #{domain.aliases} aliases)"
+        a.errors.add(:domain, message)
+      end
+    end
+
+    validates :address, presence: true, uniqueness: { case_sensitive: false },
+                        format: { with: RE_EMAIL_LIKE_WITH_ANCHORS,
+                                  message: "must be a valid email address" }
+    validates :goto, presence: true
+
+    belongs_to :rel_domain, class_name: "Domain", foreign_key: :domain
+    belongs_to :mailbox, foreign_key: :address, optional: true
+
+    scope :pure, -> { joins("LEFT OUTER JOIN mailbox ON alias.address = mailbox.username").where("mailbox.username" => nil) }
+
+    attribute :local_part, :string
+    attr_writer :forward_addresses
+
+    def forward_addresses
+      if @forward_addresses.nil?
+        if goto.nil?
+          [nil]
+        else
+          goto.split(",") + [nil]
+        end
+      else
+        @forward_addresses
+      end
+    end
+
+    before_validation do |a|
+      unless a.address
+        a.address = "#{a.local_part}@#{a.domain}" unless a.local_part.empty?
+      end
+
+      unless a.forward_addresses.empty?
+        forward_addresses = a.forward_addresses.dup
+        forward_addresses.delete_if { |f| f.blank? }
+        a.goto = forward_addresses.join(",")
+      end
+    end
+
+    def mailbox?
+      !!mailbox
+    end
+
+    def pure_alias?
+      !mailbox
+    end
+
+    def gotos
+      goto.split(",")
+    end
+  end
+end

data/lib/postfix_admin/application_record.rb

@@ -0,0 +1,44 @@
+require 'active_record'
+require 'postfix_admin/concerns/existing_timestamp'
+
+module PostfixAdmin
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+
+    include ExistingTimestamp
+
+    RE_DOMAIN_NAME_LIKE_BASE = '([a-z0-9]+(-[a-z0-9]+)*\.)+[a-z]{2,}'
+    RE_EMAIL_LIKE_BASE = '[^@\s]+@([a-z0-9]+(-[a-z0-9]+)*\.)+[a-z]{2,}'
+
+    RE_DOMAIN_NAME_LIKE = /#{RE_DOMAIN_NAME_LIKE_BASE}/
+    RE_EMAIL_LIKE = /#{RE_EMAIL_LIKE_BASE}/
+
+    RE_DOMAIN_NAME_LIKE_WITH_ANCHORS = /\A#{RE_DOMAIN_NAME_LIKE_BASE}\z/
+    RE_EMAIL_LIKE_WITH_ANCHORS = /\A#{RE_EMAIL_LIKE_BASE}\z/
+
+    scope :active, -> { where(active: true) }
+
+    def inactive?
+      !active?
+    end
+
+    def active_str
+      active? ? "Active" : "Inactive"
+    end
+
+    # This is a workaround to set current time to timestamp columns when a record is created.
+    # Activerecord does not insert timestamps if default values are set for the columns.
+    before_create :set_current_time_to_timestamp_columns, if: :has_timestamp_columns?
+
+    def set_current_time_to_timestamp_columns
+      now = Time.now
+      self.created = now
+      self.modified = now
+    end
+
+    def has_timestamp_columns?
+      column_names = self.class.column_names
+      column_names.include?("created") && column_names.include?("modified")
+    end
+  end
+end

data/lib/postfix_admin/base.rb

@@ -1,188 +1,245 @@
-require 'postfix_admin/models'
 require 'postfix_admin/error'
 
 require 'date'
-require 'data_mapper'
+require 'postfix_admin/models'
 
 module PostfixAdmin
   class Base
     attr_reader :config
 
     DEFAULT_CONFIG = {
-      'database'  => 'mysql://postfix:password@localhost/postfix',
+      'database'  => 'mysql2://postfix:password@localhost/postfix',
       'aliases'   => 30,
       'mailboxes' => 30,
-      'maxquota'  => 100
+      'maxquota'  => 100,
+      'scheme'    => 'CRAM-MD5',
     }
 
     def initialize(config)
-      db_setup(config['database'])
       @config = {}
+      @config[:database]  = config['database']
       @config[:aliases]   = config['aliases']   || 30
       @config[:mailboxes] = config['mailboxes'] || 30
       @config[:maxquota]  = config['maxquota']  || 100
-      @config[:mailbox_quota] = @config[:maxquota] * 1024 * 1000
+      @config[:scheme]    = config['scheme']    || 'CRAM-MD5'
     end
 
-    def db_setup(database)
-      DataMapper.setup(:default, database)
-      DataMapper.finalize
-    end
+    def db_setup
+      raise "'database' parameter is required in '#{CLI.config_file}'" unless @config[:database]
 
-    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}"
+      uri = URI.parse(@config[:database])
+
+      if uri.scheme == "mysql"
+        uri.scheme = "mysql2"
+        warn("Deprecation Warning: Use 'mysql2' as a DB adopter instead of 'mysql' in '#{CLI.config_file}'")
       end
 
-      admin  = Admin.find(username)
-      if admin.has_domain?(domain_name)
-        raise Error, "#{username} is already resistered as admin of #{domain_name}."
+      if uri.scheme != "mysql2"
+        raise "'#{uri.scheme}' is not supported as a DB adopter. Use 'mysql2' instead in '#{CLI.config_file}'."
       end
 
+      ActiveRecord::Base.establish_connection(uri.to_s)
+
+    rescue LoadError => e
+      raise e.message
+    end
+
+    def add_admin_domain(user_name, domain_name)
+      admin_domain_check(user_name, domain_name)
+
+      admin  = Admin.find(user_name)
       domain = Domain.find(domain_name)
-      admin.domains << domain
+
+      if admin.has_domain?(domain)
+        raise Error, "#{user_name} is already registered as admin of #{domain_name}."
+      end
+
+      admin.rel_domains << domain
       admin.save or raise "Relation Error: Domain of Admin"
     end
 
+    def delete_admin_domain(user_name, domain_name)
+      admin_domain_check(user_name, domain_name)
+
+      admin = Admin.find(user_name)
+      domain_admin_query = admin.domain_admins.where(domain: domain_name)
+
+      unless domain_admin_query.take
+        raise Error, "#{user_name} is not registered as admin of #{domain_name}."
+      end
+
+      domain_admin_query.delete_all
+    end
+
     def add_admin(username, password)
-      if Admin.exist?(username)
-        raise Error, "#{username} is already resistered as admin."
+      password_check(password)
+
+      if Admin.exists?(username)
+        raise Error, "#{username} is already registered as admin."
       end
       admin = Admin.new
       admin.attributes = {
-        :username => username,
-        :password => password,
+        username: username,
+        password: password,
       }
-      admin.save or raise "Could not save Admin"
+      unless admin.save
+        raise "Could not save Admin #{admin.errors.map(&:to_s).join}"
+      end
     end
 
-    def add_account(address, password)
+    def add_account(address, password, in_name = nil)
+      name = in_name || ''
+      password_check(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)
+      unless Domain.exists?(domain_name)
         raise Error, "Could not find domain #{domain_name}"
       end
 
-      if Alias.exist?(address)
-        raise Error, "#{address} is already resistered."
+      if Alias.exists?(address)
+        raise Error, "#{address} is already registered."
       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,
+
+      attributes = {
+          username: address,
+          password: password,
+          name: name,
+          maildir: path,
+          local_part: user,
+          quota_mb: @config[:maxquota]
       }
-      domain.mailboxes << mailbox
-      domain.save or raise "Could not save Domain"
+
+      mailbox = Mailbox.new(attributes)
+
+      domain.rel_mailboxes << mailbox
+
+      unless domain.save
+        raise "Could not save Mailbox and Domain #{mailbox.errors.map(&:to_s).join} #{domain.errors.map(&:to_s).join}"
+      end
     end
 
     def add_alias(address, goto)
-      if Mailbox.exist?(address)
+      if Mailbox.exists?(address)
         raise Error, "mailbox #{address} is already registered!"
       end
-      if Alias.exist?(address)
+      if Alias.exists?(address)
         raise Error, "alias #{address} is already registered!"
       end
-      user, domain_name = address_split(address)
-      unless Domain.exist?(domain_name)
+
+      local_part, domain_name = address_split(address)
+
+      unless Domain.exists?(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,
+      attributes = {
+        local_part: local_part,
+        goto: goto
       }
-      domain.aliases << new_alias
+      domain.rel_aliases << Alias.new(attributes)
       domain.save or raise "Could not save Alias"
     end
 
     def delete_alias(address)
-      if Mailbox.exist?(address)
+      if Mailbox.exists?(address)
         raise Error, "Can not delete mailbox by delete_alias. Use delete_account"
       end
-      unless Alias.exist?(address)
+
+      unless Alias.exists?(address)
         raise Error, "#{address} is not found!"
       end
-      Alias.all(:address => address).destroy or raise "Could not destroy Alias"
+
+      Alias.where(address: address).delete_all
     end
 
     def add_domain(domain_name)
+      domain_name = domain_name.downcase
       if domain_name !~ /.+\..+/
         raise Error, "Ivalid domain! #{domain_name}"
       end
-      if Domain.exist?(domain_name)
+      if Domain.exists?(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: domain_name,
+        description: domain_name,
+        aliases: @config[:aliases],
+        mailboxes: @config[:mailboxes],
+        maxquota: @config[:maxquota],
       }
-      domain.save or raise "Could not save Domain"
+      domain.save!
     end
 
     def delete_domain(domain_name)
-      unless Domain.exist?(domain_name)
+      domain_name = domain_name.downcase
+      unless Domain.exists?(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.rel_mailboxes.delete_all
+      domain.rel_aliases.delete_all
+
+      admin_names = domain.admins.map(&:username)
+
+      domain.admins.delete_all
 
-      domain.destroy or raise "Could not destroy Domain"
+      admin_names.each do |name|
+        next unless Admin.exists?(name)
+
+        admin = Admin.find(name)
+
+        # check if the admin is needed or not
+        if admin.rel_domains.empty?
+          admin.destroy
+        end
+      end
+
+      domain.destroy
     end
 
     def delete_admin(user_name)
-      unless Admin.exist?(user_name)
+      unless Admin.exists?(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"
+      admin.rel_domains.delete_all
+      admin.destroy!
     end
 
     def delete_account(address)
-      unless Alias.exist?(address) && Mailbox.exist?(address)
+      unless Alias.exists?(address) && Mailbox.exists?(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"
+      Mailbox.where(username: address).delete_all
+      Alias.where(address: address).delete_all
     end
 
     def address_split(address)
       address.split('@')
     end
+
+    private
+
+    def admin_domain_check(user_name, domain_name)
+      raise Error, "#{user_name} is not registered as admin." unless Admin.exists?(user_name)
+      raise Error, "Could not find domain #{domain_name}"     unless Domain.exists?(domain_name)
+    end
+
+    def password_check(password)
+      raise Error, "Empty password" if password.nil? || password.empty?
+    end
   end
 end