redmine-installer 1.0.0

data/lib/redmine-installer/plugin.rb

@@ -0,0 +1,9 @@
+module Redmine::Installer
+  module Plugin
+    autoload :Base,          'redmine-installer/plugins/base'
+    autoload :Database,      'redmine-installer/plugins/database'
+    autoload :EmailSending,  'redmine-installer/plugins/email_sending'
+    autoload :WebServer,     'redmine-installer/plugins/web_server'
+    autoload :RedminePlugin, 'redmine-installer/plugins/redmine_plugin'
+  end
+end

data/lib/redmine-installer/plugins/base.rb

@@ -0,0 +1,28 @@
+module Redmine::Installer::Plugin
+  class Base
+
+    include Redmine::Installer::Utils
+    
+    # Register children
+    def self.inherited(child)
+      all << child
+    end
+
+    def self.all
+      unless self.instance_variable_defined?(:@all)
+        self.instance_variable_set(:@all, Array.new)
+      end
+      
+      self.instance_variable_get(:@all)
+    end
+
+    def self.title
+      translate("plugin.#{self.superclass.class_name.downcase}.#{self.class_name.downcase}.title")
+    end
+
+    # def self.plugin_name
+    #   binding.pry unless @__binding
+    # end
+
+  end
+end

data/lib/redmine-installer/plugins/database.rb

@@ -0,0 +1,168 @@
+require 'yaml'
+
+module Redmine::Installer::Plugin
+  class Database < Base
+
+    DATABASE_YML_PATH = 'config/database.yml'
+    DATABASE_BACKUP_DIR = '__database'
+
+    attr_reader :params
+
+    def self.load_all(redmine_root)
+      database_file = File.join(redmine_root, DATABASE_YML_PATH)
+      return [] unless File.exist?(database_file)
+
+      to_return = []
+      definitions = YAML.load_file(database_file)
+      definitions.each do |name, data|
+
+        klass = all.detect{|klass| klass.adapter_name == data['adapter']}
+
+        next if klass.nil?
+
+        klass = klass.new
+        klass.load(data)
+
+        to_return << klass
+      end
+      to_return
+    end
+
+    def self.backup_all(redmine_root, backup_dir)
+      load_all(redmine_root).each do |klass|
+        klass.backup(backup_dir)
+      end
+    end
+
+    def self.restore_all(redmine_root, backup_dir)
+      load_all(redmine_root).each do |klass|
+        klass.restore(backup_dir)
+      end
+    end
+
+    def initialize
+      @params = Redmine::Installer::ConfigParams.new
+      @params.add('database')
+      @params.add('host').default('localhost')
+      @params.add('username')
+      @params.add('password')
+      @params.add('encoding').default('utf8')
+    end
+
+    # Transform ConfigParams into rails database.yml structure.
+    # Method creates production and developemtn environemnt
+    # with the same parameters.
+    def build
+      data = Hash[@params.map{|p| [p.name, p.value]}]
+      data['adapter'] = self.class.adapter_name
+      data = {
+        'production' => data,
+        'development' => data,
+      }
+      data
+    end
+
+    # Load paramaters for connection
+    def load(data)
+      data.each do |name, value|
+        # Get param
+        param = @params[name]
+
+        # Unsupported key or unnecessary parameter
+        next if param.nil?
+
+        # Save value
+        param.value = value
+      end
+    end
+
+    def make_config(redmine_root)
+      File.open(File.join(redmine_root, DATABASE_YML_PATH), 'w') do |f|
+        f.puts(YAML.dump(build))
+      end
+    end
+
+    def file_for_backup(dir)
+      FileUtils.mkdir_p(File.join(dir, DATABASE_BACKUP_DIR))
+      File.join(dir, DATABASE_BACKUP_DIR, "#{self.class.adapter_name}.#{params['database'].value}.dump")
+    end
+
+    def backup(dir)
+      file = file_for_backup(dir)
+
+      # More enviroments can use the same database
+      return if File.exist?(file)
+
+      Kernel.system(command_for_backup(file))
+    end
+
+    def restore(dir)
+      file = file_for_backup(dir)
+
+      # More enviroments can use the same database
+      return unless File.exist?(file)
+
+      Kernel.system(command_for_restore(file))
+    end
+
+    # Get valu from param
+    def get(name)
+      params[name].value
+    end
+
+
+    # =========================================================================
+    # MySQL
+
+    class MySQL < Database
+      def self.adapter_name
+        'mysql2'
+      end
+
+      def initialize
+        super
+        @params.add('port').default(3306)
+      end
+
+      def command_args
+        "-h #{params['host'].value} -P #{get('port')} -u #{get('username')} -p#{get('password')} #{get('database')}"
+      end
+
+      def command_for_backup(file)
+        "mysqldump --add-drop-database #{command_args} > #{file}"
+      end
+
+      def command_for_restore(file)
+        "mysql #{command_args} < #{file}"
+      end
+    end
+
+
+    # =========================================================================
+    # PostgreSQL
+
+    class PostgreSQL < Database
+      def self.adapter_name
+        'pg'
+      end
+
+      def initialize
+        super
+        @params.add('port').default(5432)
+      end
+
+      def command(comm, file)
+        %{PGPASSWORD="#{get('password')}" #{comm} -i -h #{get('host')} -p #{get('port')} -U #{get('username')} -Fc -f #{file}}
+      end
+
+      def command_for_backup(file)
+        command('pg_dump', file)
+      end
+
+      def command_for_restore(file)
+        command('psql', file)
+      end
+    end
+
+  end
+end

data/lib/redmine-installer/plugins/email_sending.rb

@@ -0,0 +1,82 @@
+module Redmine::Installer::Plugin
+  class EmailSending < Base
+
+    CONFIGURATION_YML_PATH = 'config/configuration.yml'
+
+    attr_reader :params
+
+    def initialize
+      @params = Redmine::Installer::ConfigParams.new
+      @params.add('user_name')
+      @params.add('password')
+    end
+
+    def build
+      {
+        'default' => {
+          'email_delivery' => {
+            'delivery_method' => delivery_method,
+            "#{delivery_method}_settings" => delivery_settings
+          }
+        }
+      }
+    end
+
+    def make_config(redmine_root)
+      File.open(File.join(redmine_root, CONFIGURATION_YML_PATH), 'w') do |f|
+        f.puts(YAML.dump(build))
+      end
+    end
+
+    def delivery_method
+      :smtp
+    end
+
+    # Build ConfigParams
+    def delivery_settings
+      settings = {}
+      @params.each do |param|
+        next if param.value.empty?
+        settings[param.name] = param.value
+      end
+      settings
+    end
+  end
+
+  class Gmail < EmailSending
+    def delivery_settings
+      super.merge({
+        'enable_starttls_auto' => true,
+        'address' => 'smtp.gmail.com',
+        'port' => 587,
+        'domain' => 'smtp.gmail.com',
+        'authentication' => :plain
+      })
+    end
+  end
+
+  class SendMail < EmailSending
+    def initialize
+      @params = Redmine::Installer::ConfigParams.new
+      @params.add('location').default('/usr/sbin/sendmail')
+      @params.add('arguments').default('-i -t')
+    end
+
+    def delivery_method
+      :sendmail
+    end
+  end
+
+  class SMTPFromScratch < EmailSending
+    def initialize
+      @params = Redmine::Installer::ConfigParams.new
+      @params.add('address')
+      @params.add('port').default(587)
+      @params.add('domain')
+      @params.add('user_name')
+      @params.add('password')
+      @params.add('authentication')
+      @params.add('enable_starttls_auto')
+    end
+  end
+end

data/lib/redmine-installer/plugins/redmine_plugin.rb

@@ -0,0 +1,30 @@
+module Redmine::Installer::Plugin
+  class RedminePlugin < Base
+
+    # Search plugins folder
+    def self.am_i_there?
+      records = Dir.glob(File.join('plugins', '*'))
+      records.map! do |record|
+        File.basename(record)
+      end
+
+      records.include?(self.class_name.downcase)
+    end
+
+    class EasyProject < RedminePlugin
+
+      RAKE_EASYPROJECT_INSTALL = 'bundle exec rake easyproject:install RAILS_ENV=production'
+
+      def self.install
+        if am_i_there?
+          run_command(RAKE_EASYPROJECT_INSTALL, t('plugin.redmine_plugin.easyproject.install'))
+        end
+      end
+
+      def self.upgrade
+        install
+      end
+    end
+
+  end
+end

data/lib/redmine-installer/plugins/web_server.rb

@@ -0,0 +1,26 @@
+module Redmine::Installer::Plugin
+  class WebServer < Base
+
+    # Generate config based on class and redmine_root.
+    # Texts are in lang files.
+    def self.generate_config(redmine_root)
+      translate("plugin.#{self.superclass.class_name.downcase}.#{self.class_name.downcase}.configuration", redmine_root: redmine_root)
+    end
+
+    class Webrick < WebServer
+    end
+
+    class Thin < WebServer
+    end
+
+    class ApachePassenger < WebServer
+    end
+
+    class NginxPassenger < WebServer
+    end
+
+    class Puma < WebServer
+    end
+
+  end
+end

data/lib/redmine-installer/profile.rb

@@ -0,0 +1,74 @@
+require 'fileutils'
+require 'yaml'
+
+module Redmine::Installer
+  class Profile
+
+    include Redmine::Installer::Utils
+
+    CONFIG_FILE = File.join(Dir.home, '.redmine-installer-profiles.yml')
+    
+    def self.save(task)
+      return unless check_writable
+      return unless confirm(:do_you_want_save_step_for_further_use, true)
+
+      profile = Profile.new(task)
+      profile.save
+
+      say t(:your_profile_can_be_used_as, id: profile.id), 2
+    end
+
+    def self.load(task, id)
+      profile = Profile.new(task)
+      profile.load(id)
+    end
+
+    def self.check_writable
+      FileUtils.touch(CONFIG_FILE)
+      File.writable?(CONFIG_FILE)
+    end
+
+    attr_accessor :task
+
+    def initialize(task)
+      self.task = task
+
+      # Load profiles
+      @data = YAML.load_file(CONFIG_FILE) rescue nil
+
+      # Make empty Hash if there is no profiles
+      @data = {} unless @data.is_a?(Hash)
+    end
+
+    def id
+      @id ||= @data.keys.map(&:to_i).max.to_i + 1
+    end
+
+    def save
+      # All steps save configuration which can be use again
+      configuration = {}
+      task.steps.each do |_, step|
+        step.save(configuration)
+      end
+
+      @data[id] = configuration
+
+      File.open(CONFIG_FILE, 'w') {|f| f.puts(YAML.dump(@data))}
+    end
+
+    def load(id)
+      @id = id.to_i
+
+      configuration = @data[@id]
+
+      return {} if configuration.nil?
+
+      task.steps.each do |_, step|
+        step.load(configuration)
+      end
+
+      return configuration
+    end
+
+  end
+end

data/lib/redmine-installer/step.rb

@@ -0,0 +1,15 @@
+module Redmine::Installer
+  module Step
+    autoload :Base,            'redmine-installer/steps/base'
+    autoload :LoadPackage,     'redmine-installer/steps/load_package'
+    autoload :DatabaseConfig,  'redmine-installer/steps/database_config'
+    autoload :EmailConfig,     'redmine-installer/steps/email_config'
+    autoload :Install,         'redmine-installer/steps/install'
+    autoload :MoveRedmine,     'redmine-installer/steps/move_redmine'
+    autoload :WebserverConfig, 'redmine-installer/steps/webserver_config'
+    autoload :Validation,      'redmine-installer/steps/validation'
+    autoload :Backup,          'redmine-installer/steps/backup'
+    autoload :Upgrade,         'redmine-installer/steps/upgrade'
+    autoload :RedmineRoot,     'redmine-installer/steps/redmine_root'
+  end
+end

data/lib/redmine-installer/steps/backup.rb

@@ -0,0 +1,120 @@
+require 'fileutils'
+require 'zip'
+
+module Redmine::Installer::Step
+  class Backup < Base
+
+    DEFAULT_BACKUP_DIR = File.join(Dir.home, 'redmine-backups')
+
+    def up
+      choices = {}
+      choices[:full_backup] = t(:full_backup)
+      choices[:backup] = t(:backup)
+      choices[:only_database] = t(:only_database)
+      choices[:skip] = t(:skip)
+
+      @backup_type ||= choose(:do_you_want_backup_redmine, choices, default: :backup)
+
+      case @backup_type
+      when :full_backup
+        do_full_backup
+      when :backup
+        do_backup
+      when :only_database
+        database_backup
+      end
+    end
+
+    def down
+      database_restore if @database_backed_up
+    end
+
+    def final_step
+      if @current_backup_dir
+        say t(:backup_is_stored_at, dir: @current_backup_dir), 2
+      end
+    end
+
+    def save(configuration)
+      configuration['backup_type'] = @backup_type
+      configuration['backup_dir'] = @backup_dir
+    end
+
+    def load(configuration)
+      @backup_type = configuration['backup_type']
+      @backup_dir = configuration['backup_dir']
+    end
+
+    private
+
+      def check_backup_dir
+        if @backup_dir.nil?
+          dir = ask(:what_dir_for_backups, default: DEFAULT_BACKUP_DIR)
+          dir = File.expand_path(dir)
+
+          try_create_dir(dir) unless Dir.exist?(dir)
+
+          @backup_dir = dir
+        end
+      end
+
+      def create_current_backup_dir
+        return if @current_backup_dir
+
+        check_backup_dir
+        @current_backup_dir = File.join(@backup_dir, Time.now.strftime('backup_%d%m%Y_%H%M%S'))
+        try_create_dir(@current_backup_dir)
+      end
+
+      def database_backup
+        create_current_backup_dir
+
+        plugin::Database.backup_all(base.redmine_root, @current_backup_dir)
+        @database_backed_up = true
+      end
+
+      def database_restore
+        plugin::Database.restore_all(base.redmine_root, @current_backup_dir)
+      end
+
+      def do_full_backup
+        create_current_backup_dir
+
+        zipfile_name = File.join(@current_backup_dir, 'redmine.zip')
+
+        Dir.chdir(base.redmine_root) do
+          Zip::File.open(zipfile_name, Zip::File::CREATE) do |zipfile|
+            Dir.glob(File.join('**', '{*,.*}')).each do |entry|
+              next if entry.end_with?('.') || entry.end_with?('..')
+
+              zipfile.add(entry, entry)
+            end
+          end
+        end
+
+        database_backup
+      end
+
+      def do_backup
+        create_current_backup_dir
+
+        # create config dir
+        config_dir = File.join(@current_backup_dir, 'config')
+        FileUtils.mkdir(config_dir)
+
+        # database.yml
+        database_file = File.join(base.redmine_root, plugin::Database::DATABASE_YML_PATH)
+        FileUtils.cp(database_file, config_dir) if File.exist?(database_file)
+
+        # configuration.yml
+        configuration_file = File.join(base.redmine_root, plugin::EmailSending::CONFIGURATION_YML_PATH)
+        FileUtils.cp(configuration_file, config_dir) if File.exist?(configuration_file)
+
+        # files
+        FileUtils.cp_r(File.join(base.redmine_root, 'files'), @current_backup_dir)
+
+        database_backup
+      end
+
+  end
+end