redmine-installer 1.0.7 → 2.0.0.rc1

data/lib/redmine-installer/command.rb

@@ -1,144 +1,90 @@
-require 'singleton'
+require 'open3'
 
-module Redmine::Installer
+module RedmineInstaller
   class Command
-    include Singleton
-    include Redmine::Installer::Utils
+    include Utils
 
-    RAKE = 'bundle exec rake'
+    attr_reader :cmd, :title, :formatter
 
-    def bundle_install(env)
-      run('bundle install', get_bundle_env(env), :'command.bundle_install')
+    def initialize(cmd, title: nil)
+      @cmd = cmd
+      @title = title || cmd
+      @formatter = $SILENT_MODE ? SilentFormatter.new : FullFormatter.new
     end
 
-    def rake_db_create(env)
-      run(RAKE, 'db:create', get_rails_env(env), :'command.rake_db_create')
-    end
+    def run
+      success = false
 
-    def rake_db_migrate(env)
-      run(RAKE, 'db:migrate', get_rails_env(env), :'command.rake_db_migrate')
-    end
+      logger.std("--> #{cmd}")
 
-    def rake_redmine_plugin_migrate(env)
-      run(RAKE, 'redmine:plugins:migrate', get_rails_env(env), :'command.rake_redmine_plugin_migrate')
-    end
+      formatter.print_title(title)
 
-    def rake_generate_secret_token(env)
-      run(RAKE, 'generate_secret_token', get_rails_env(env), :'command.rake_generate_secret_token')
-    end
+      status = Open3.popen2e(cmd) do |input, output, wait_thr|
+        input.close
 
-    private
+        output.each_line do |line|
+          logger.std(line)
+          formatter.print_line(line)
+        end
 
-      def run(*args)
-        _args = args.dup
+        wait_thr.value
+      end
 
-        # Last element is title
-        title = args.pop
-        title = translate(title) if title.is_a?(Symbol)
-        title = "--> <yellow>#{title}</yellow>"
-        colorize(title)
+      success = status.success?
+    rescue => e
+      success = false
+    ensure
+      formatter.print_end(success)
+    end
 
-        command = args.join(' ')
 
+    class BaseFormatter
+      include Utils
+    end
+
+    class FullFormatter < BaseFormatter
+
+      def print_title(title)
         puts '-->'
-        puts title
+        puts "--> #{pastel.yellow(title)}"
         puts '-->'
-        success = Kernel.system(command)
-
-        unless success
-          if confirm(:do_you_want_repeat_command, false)
-            return run(*_args)
-          else
-            error(:command_exit_with_error, command: command)
-          end
-        end
+      end
 
-        return success
+      def print_line(line)
+        puts line
       end
 
-      def get_rails_env(env)
-        if    env.include?('production');  'RAILS_ENV=production'
-        elsif env.include?('development'); 'RAILS_ENV=development'
-        elsif env.include?('test');        'RAILS_ENV=test'
-        else
-          ''
-        end
+      def print_end(*)
       end
 
-      def get_bundle_env(env)
-        if env.include?('production')
-          '--without development test'
+    end
+
+    class SilentFormatter < BaseFormatter
+
+      def initialize
+        @output = ''
+      end
+
+      def print_title(title)
+        format = "[#{pastel.yellow(':spinner')}] #{title}"
+        @spinner = TTY::Spinner.new(format, success_mark: pastel.green('✔'), error_mark: pastel.red('✖'))
+        @spinner.auto_spin
+      end
+
+      def print_line(line)
+        @output << line
+      end
+
+      def print_end(success)
+        if success
+          @spinner.success
         else
-          ''
+          @spinner.error
+          puts @output
         end
       end
 
+    end
+
   end
 end
-
-##
-# Class for easier create complex command
-#
-# == Examples:
-#
-# Instead of this:
-#   exec('rake redmine:plugins:migrate RAILS_ENV=production')
-#
-# you can write:
-#   rake.plugin_migrate.production.run
-#
-# module Redmine::Installer
-#   module Command
-#     class Base
-#       # Register main command only for child class
-#       def self.command(cmd)
-#         self.class_variable_set('@@command', cmd)
-#       end
-
-#       # Register new argument and method name
-#       def self.add(name, cmd)
-#         self.class_eval <<-EVAL
-#           def #{name}
-#             arguments << '#{cmd}'
-#             self
-#           end
-#         EVAL
-#       end
-
-#       def initialize(command=nil)
-#         @command = self.class.class_variable_get('@@command')
-#       end
-
-#       def arguments
-#         @arguments ||= []
-#       end
-
-#       def command
-#         %{#{@command} #{arguments.join(' ')}}
-#       end
-
-#       def run(title=nil, with_timer=false)
-#         Redmine::Installer::Exec.new(command, title, with_timer).run
-#       end
-
-#       def repeatable_run(title=nil, with_timer=false)
-#         Redmine::Installer::Exec.new(command, title, with_timer).repeatable_run
-#       end
-#     end
-
-#     class Rake < Base
-#       command 'bundle exec rake'
-#       add 'db_create',  'db:create'
-#       add 'db_migrate', 'db:migrate'
-#       add 'generate_secret_token', 'generate_secret_token'
-#       add 'redmine_plugin_migrate', 'redmine:plugins:migrate'
-#       add 'production', 'RAILS_ENV=production'
-#     end
-
-#     class Bundle < Base
-#       command 'bundle'
-#       add 'install', 'install'
-#       add 'production', '--without development test'
-#     end
-#   end
-# end

data/lib/redmine-installer/configuration.rb

@@ -0,0 +1,148 @@
+module RedmineInstaller
+  ##
+  # RedmineInstaller::Configuration
+  #
+  # For now, email is only configured.
+  #
+  class Configuration
+    extend Utils
+
+    def self.create_config(redmine)
+      # Maybe: enum_select
+      klass = prompt.select('Which service to use for email sending?') do |menu|
+        menu.default 4
+
+        menu.choice 'Custom configuration (SMTP)', CustomConfiguration
+        menu.choice 'Gmail', Gmail
+        menu.choice 'SendMail', SendMail
+        menu.choice 'Nothing', Nothing
+      end
+
+      # Get parameters and create configuration
+      database = klass.new(redmine)
+      database.get_parameters
+      database.make_config
+      database
+    end
+
+    class Base
+      include RedmineInstaller::Utils
+
+      def initialize(redmine)
+        @redmine = redmine
+      end
+
+      def get_parameters
+        @username = prompt.ask('Username:', required: true)
+        @password = prompt.mask('Password:', required: true)
+      end
+
+      def make_config
+        File.open(@redmine.configuration_yml_path, 'w') do |f|
+          f.puts(YAML.dump(build))
+        end
+      end
+
+      def build
+        {
+          'default' => {
+            'email_delivery' => {
+              'delivery_method' => delivery_method,
+              "#{delivery_method}_settings" => delivery_settings
+            }
+          }
+        }
+      end
+
+      def delivery_method
+        :smtp
+      end
+
+      def delivery_settings
+        settings = {}
+
+        # Required
+        settings['address'] = @address
+        settings['port']    = @port
+
+        # Optional
+        settings['authentication']       = @authentication  unless @authentication.to_s.empty?
+        settings['domain']               = @domain          unless @domain.to_s.empty?
+        settings['user_name']            = @user_name       unless @user_name.to_s.empty?
+        settings['password']             = @password        unless @password.to_s.empty?
+        settings['enable_starttls_auto'] = @enable_starttls unless @enable_starttls.to_s.empty?
+        settings['openssl_verify_mode']  = @openssl_verify  unless @openssl_verify.to_s.empty?
+
+        settings
+      end
+
+      def to_s
+        "<#{class_name} #{@username}@#{@address}:#{@port}>"
+      end
+
+    end
+
+    class Nothing < Base
+
+      def get_parameters(*) end
+      def make_config(*) end
+
+      def to_s(*)
+        "<Nothing>"
+      end
+
+    end
+
+    class Gmail < Base
+
+      def get_parameters
+        super
+        @address = 'smtp.gmail.com'
+        @port = 587
+        @domain = 'smtp.gmail.com'
+        @authentication = :plain
+        @enable_starttls = true
+      end
+
+    end
+
+    class CustomConfiguration < Base
+
+      def get_parameters
+        super
+        @address = prompt.ask('Address:', required: true)
+        @port = prompt.ask('Port:', convert: lambda(&:to_i), required: true)
+        @domain = prompt.ask('Domain:')
+        @authentication = prompt.ask('Authentication:')
+        @openssl_verify = prompt.ask('Openssl verify mode:')
+        @enable_starttls = prompt.yes?('Enable starttls?:', default: true)
+      end
+
+    end
+
+    class SendMail < Base
+
+      def get_parameters
+        @location = prompt.ask('Location:', default: '/usr/sbin/sendmail', required: true)
+        @arguments = prompt.ask('Arguments:', default: '-i -t')
+      end
+
+      def delivery_method
+        :sendmail
+      end
+
+      def delivery_settings
+        {
+          'location' => @location,
+          'arguments' => @arguments
+        }
+      end
+
+      def to_s
+        "<SendMail #{@location} #{@arguments}>"
+      end
+
+    end
+
+  end
+end

data/lib/redmine-installer/database.rb

@@ -0,0 +1,204 @@
+module RedmineInstaller
+  class Database
+    extend Utils
+
+    def self.create_config(redmine)
+      # Maybe: enum_select
+      klass = prompt.select('What database do you want use?') do |menu|
+        menu.choice 'MySQL', MySQL
+        menu.choice 'PostgreSQL', PostgreSQL
+      end
+
+      # Get parameters and create configuration
+      database = klass.new(redmine)
+      database.get_parameters
+      database.make_config
+      database
+    end
+
+    def self.init(redmine)
+      unless File.exist?(redmine.database_yml_path)
+        error "Database configuration files does not exist on #{redmine.root}."
+      end
+
+      definitions = YAML.load_file(redmine.database_yml_path)
+      definition = definitions['production']
+
+      unless definition.is_a?(Hash)
+        error 'Unknow database definition'
+      end
+
+      case definition['adapter']
+      when 'mysql', 'mysql2'
+        klass = MySQL
+      when 'pg', 'postgresql'
+        klass = PostgreSQL
+      else
+        error "Unknow database adapter #{definition['adapter']}."
+      end
+
+      database = klass.new(redmine)
+      database.set_paramaters(definition)
+      database
+    end
+
+    class Base
+      include RedmineInstaller::Utils
+
+      attr_reader :backup
+
+      def initialize(redmine)
+        @redmine = redmine
+      end
+
+      def backuped?
+        @backup && File.exist?(@backup)
+      end
+
+      def get_parameters
+        @database = prompt.ask('Database:', required: true)
+        @host = prompt.ask('Host:', default: 'localhost', required: true)
+        @username = prompt.ask('Username:', default: '')
+        @password = prompt.mask('Password:', default: '')
+        @encoding = prompt.ask('Encoding:', default: 'utf8', required: true)
+        @port = prompt.ask('Port:', default: default_port, convert: lambda(&:to_i), required: true)
+      end
+
+      def set_paramaters(definition)
+        @database = definition['database']
+        @username = definition['username']
+        @password = definition['password']
+        @encoding = definition['encoding']
+        @host = definition['host']
+        @port = definition['port']
+      end
+
+      def make_config
+        File.open(@redmine.database_yml_path, 'w') do |f|
+          f.puts(YAML.dump(build))
+        end
+      end
+
+      def make_backup(dir)
+        puts 'Database backuping'
+        @backup = File.join(dir, "#{@database}.sql")
+        Kernel.system backup_command(@backup)
+      end
+
+      # Recreate database should be done in 2 commands because of
+      # postgre's '--command' options which can do only 1 operations.
+      # Otherwise result is unpredictable.
+      def do_restore(file)
+        puts 'Database cleaning'
+        Kernel.system drop_database_command
+        Kernel.system create_database_command
+
+        puts 'Database restoring'
+        Kernel.system restore_command(file)
+      end
+
+      def build
+        data = {}
+        data['adapter'] = adapter_name
+        data['database'] = @database
+        data['username'] = @username if @username.present?
+        data['password'] = @password if @password.present?
+        data['encoding'] = @encoding
+        data['host'] = @host
+        data['port'] = @port
+
+        {
+          'production' => data,
+          'development' => data
+        }
+      end
+
+      def to_s
+        "<#{class_name} #{@username}@#{@host}:#{@port} (#{@encoding})>"
+      end
+
+    end
+
+    class MySQL < Base
+
+      def default_port
+        3306
+      end
+
+      def adapter_name
+        'mysql2'
+      end
+
+      def command_args
+        args = []
+        args << "--host=#{@host}"         unless @host.to_s.empty?
+        args << "--port=#{@port}"         unless @port.to_s.empty?
+        args << "--user=#{@username}"     unless @username.to_s.empty?
+        args << "--password=#{@password}" unless @password.to_s.empty?
+        args.join(' ')
+      end
+
+      def create_database_command
+        "mysql #{command_args} --execute=\"create database #{@database}\""
+      end
+
+      def drop_database_command
+        "mysql #{command_args} --execute=\"drop database #{@database}\""
+      end
+
+      def backup_command(file)
+        "mysqldump --add-drop-database --compact --result-file=#{file} #{command_args} #{@database}"
+      end
+
+      def restore_command(file)
+        "mysql #{command_args} #{@database} < #{file}"
+      end
+
+    end
+
+    class PostgreSQL < Base
+
+      def default_port
+        5432
+      end
+
+      def adapter_name
+        'postgresql'
+      end
+
+      def command_args
+        args = []
+        args << "--host=#{@host}"         unless @host.to_s.empty?
+        args << "--port=#{@port}"         unless @port.to_s.empty?
+        args << "--username=#{@username}" unless @username.to_s.empty?
+        args.join(' ')
+      end
+
+      def cli_password
+        if @password.present?
+          "PGPASSWORD=\"#{@password}\""
+        else
+          ''
+        end
+      end
+
+      def create_database_command
+        "#{cli_password} psql #{command_args} --command=\"create database #{@database};\""
+      end
+
+      def drop_database_command
+        "#{cli_password} psql #{command_args} --command=\"drop database #{@database};\""
+      end
+
+      def backup_command(file)
+        "#{cli_password} pg_dump --clean #{command_args} --format=custom --file=#{file} #{@database}"
+      end
+
+      def restore_command(file)
+        "#{cli_password} pg_restore --clean #{command_args} --dbname=#{@database} #{file} 2>/dev/null"
+      end
+
+    end
+
+  end
+end