postfix_admin 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 69e3627f6b08953a75386f7c16256f03c2aacc2801c611c297f4a8e8b7249cb5
-  data.tar.gz: 982ceb31f432be52fa7a4960810fac0d84dddc6f7138d02be69d2a8fb7aeda26
+  metadata.gz: a83f945f0f977fc80b8715b899af26d908b3d6b1169d27fae9cf92089bac5082
+  data.tar.gz: f8f63116ece1064079b99f986fc26778c4f4affc28ae8dbd3beca3496a595186
 SHA512:
-  metadata.gz: 878ee894a9cb4b209361167e310569163c2eb6737ebf6a119a039b7ee55518439fe79ed5ed500b48b423c299acc852e6f7ed8d9d6077978fa0a46bacb7090195
-  data.tar.gz: 8abda8f37ac2d31bc38e1ace3ac225c2ee17813e80e7e8be60a3b4abb9539257ae959ea8ab6f3d1cdd4c72cedd2100d9e5f769c92e07ceaa69910de868c6d282
+  metadata.gz: 22f7cc6d351d3a7e63ba95e653ac21f4b1eeebaebb5a717810477ab0d700dbb3199eeee042ca34909aee1c959bb7d27fe705d1c332895e7bb38ae0cc1f3e9120
+  data.tar.gz: 821bb8bac75277e3faf303f1db8292256cc9bbcf40cb2de6f63f9c3c38e40f84c5739849edc159ddec8bf262d9fa9e5ea8f9bac15e8dce37f2691f0a017e2772

data/.rubocop.yml

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

data/CHANGELOG.md

@@ -1,16 +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
- * Add "log" command
+ * Added "log" subcommand
 
 ## 0.1.3
  * Support for activation and deactivation of domain, admin and account
- * Add "edit_admin" command
+ * Added "edit_admin" subcommand
 
 ## 0.1.2
- * Support password hash by doveadm (external command)
+ * 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,19 +1,20 @@
 [![Gem Version](https://badge.fury.io/rb/postfix_admin.png)](https://rubygems.org/gems/postfix_admin)
 
-# PostfixAdmin
+# postfix_admin
 
-Command Line Tools of Postfix Admin
+Command Line Tools for Postfix Admin
 
 ## Description
 
-Postfix Admin Web Site http://postfixadmin.sourceforge.net/
+* Postfix Admin (Original Web-based Application)
+  + Web Site http://postfixadmin.sourceforge.net/
+  + GitHub https://github.com/postfixadmin/postfixadmin
 
-Sourceforge page http://sourceforge.net/projects/postfixadmin/
+* Postfix Admin 3.2 is supported.
 
-This software supports only MySQL as database for Postfix Admin.
-PostgreSQL is not supported.
+* MySQL/MariaDB is supported.
 
-Postfix Admin 2.2.0 is supported.
+* Other database engines are not supported.
 
 ## Installation
 
@@ -21,6 +22,18 @@ 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
 
 List the postfix_admin subcommands as:
@@ -44,19 +57,13 @@ Commands:
   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
 ```
-
-## Contributing
-
-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

data/Rakefile

@@ -1 +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/{bin → exe}/postfix_admin

@@ -1,5 +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

@@ -2,5 +2,5 @@ require "postfix_admin/version"
 require "postfix_admin/base"
 
 module PostfixAdmin
-  KB_TO_MB = 1024000
+  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,15 +1,14 @@
-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,
@@ -17,71 +16,78 @@ module PostfixAdmin
     }
 
     def initialize(config)
-      db_setup(config['database'])
-      if local_part_required?
-        eval <<"EOS"
-class ::PostfixAdmin::Mailbox
-    property :local_part, String
-end
-EOS
-        DataMapper.finalize
-      end
       @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] * KB_TO_MB
       @config[:scheme]    = config['scheme']    || 'CRAM-MD5'
     end
 
-    def db_setup(database)
-      DataMapper.setup(:default, database)
-      DataMapper.finalize
+    def db_setup
+      raise "'database' parameter is required in '#{CLI.config_file}'" unless @config[:database]
+
+      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
+
+      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)
-      if admin.has_domain?(domain_name)
-        raise Error, "#{user_name} is already resistered as admin of #{domain_name}."
+      domain = Domain.find(domain_name)
+
+      if admin.has_domain?(domain)
+        raise Error, "#{user_name} is already registered as admin of #{domain_name}."
       end
 
-      domain = Domain.find(domain_name)
-      admin.domains << domain
+      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)
-      unless admin.has_domain?(domain_name)
-        raise Error, "#{user_name} is not resistered as admin of #{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 = Domain.find(domain_name)
-      admin.domains.delete(domain)
-      admin.save or "Could not save Admin"
+      domain_admin_query.delete_all
     end
 
     def add_admin(username, password)
       password_check(password)
 
-      if Admin.exist?(username)
-        raise Error, "#{username} is already resistered as admin."
+      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,
       }
       unless admin.save
-        raise "Could not save Admin #{admin.errors.map{|e| e.to_s}.join}"
+        raise "Could not save Admin #{admin.errors.map(&:to_s).join}"
       end
     end
 
-    def add_account(address, password, in_name=nil)
+    def add_account(address, password, in_name = nil)
       name = in_name || ''
       password_check(password)
 
@@ -91,68 +97,68 @@ EOS
       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)
-      domain.aliases << Alias.mailbox(address)
 
-      mailbox = Mailbox.new
       attributes = {
-        :username => address,
-        :password => password,
-        :name     => name,
-        :maildir  => path,
-        :quota    => @config[:mailbox_quota],
+          username: address,
+          password: password,
+          name: name,
+          maildir: path,
+          local_part: user,
+          quota_mb: @config[:maxquota]
       }
 
-      if local_part_required?
-        attributes[:local_part] = user
-      end
+      mailbox = Mailbox.new(attributes)
 
-      mailbox.attributes = attributes
+      domain.rel_mailboxes << mailbox
 
-      domain.mailboxes << mailbox
       unless domain.save
-        raise "Could not save Mailbox and Domain #{mailbox.errors.map{|e| e.to_s}.join} #{domain.errors.map{|e| e.to_s}.join}"
+        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)
@@ -160,56 +166,65 @@ EOS
       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)
       domain_name = domain_name.downcase
-      unless Domain.exist?(domain_name)
+      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"
-      admin_names = domain.admins.map{|a| a.username }
-      domain.clear_admins
+      domain.rel_mailboxes.delete_all
+      domain.rel_aliases.delete_all
+
+      admin_names = domain.admins.map(&:username)
+
+      domain.admins.delete_all
 
       admin_names.each do |name|
-        next unless Admin.exist?(name)
+        next unless Admin.exists?(name)
+
         admin = Admin.find(name)
-        admin.destroy or raise "Could not destroy Admin" if admin.domains.empty?
+
+        # check if the admin is needed or not
+        if admin.rel_domains.empty?
+          admin.destroy
+        end
       end
-      domain.destroy or raise "Could not destroy Domain"
+
+      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.clear_domains
-      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"
+      Mailbox.where(username: address).delete_all
+      Alias.where(address: address).delete_all
     end
 
     def address_split(address)
@@ -218,14 +233,9 @@ EOS
 
     private
 
-    # postfixadmin DB upgrade Number 495 loca_part added
-    def local_part_required?
-      Config.first.value.to_i >= 495
-    end
-
     def admin_domain_check(user_name, domain_name)
-      raise Error, "#{user_name} is not resistered as admin." unless Admin.exist?(user_name)
-      raise Error, "Could not find domain #{domain_name}"     unless Domain.exist?(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)