redmine-installer 1.0.7 → 2.0.0.rc1

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

@@ -1,82 +0,0 @@
-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
-
-    def self.final(*)
-    end
-
-  end
-end
-
-##
-# EasyProject
-#
-# http://www.easyredmine.com
-#
-# Easy Redmine is complex project management web application best suited to project teams between
-# 10 - 100 users. Whether you manage just yourself or a huge team of software developers,
-# Easy Redmine will provide all necessary project management features to complete your projects
-# on time, scope and budget.
-#
-class EasyProject < Redmine::Installer::Plugin::RedminePlugin
-
-  class Redmine::Installer::Command
-    def rake_easyproject_install(env)
-      run(RAKE, 'easyproject:install', get_rails_env(env), :'plugin.redmine_plugin.easyproject.install')
-    end
-  end
-
-  def self.install(base)
-    command.rake_easyproject_install(base.env) if am_i_there?
-  end
-
-  def self.upgrade(base)
-    # Copy client modification folders
-    # plugins/easyproject/easy_plugins/modification_*
-    unless base.options['skip-old-modifications']
-      easy_plugins_dir = File.join('plugins', 'easyproject', 'easy_plugins')
-      old_modifications = Dir.glob(File.join(base.redmine_root, easy_plugins_dir, 'modification_*'))
-      new_modifications = Dir.glob(File.join(base.tmp_redmine_root, easy_plugins_dir, 'modification_*'))
-
-      # Modifications which are on old redmine but not new
-      missing_modifications = old_modifications - new_modifications
-
-      FileUtils.cp_r(missing_modifications, File.join(base.tmp_redmine_root, easy_plugins_dir))
-    end
-
-    install(base)
-  end
-
-  def self.final(base)
-    return unless am_i_there?
-
-    say %{
-<bright>EasyRedmine notes:</bright>
-  You should create a maintenance task to CRON (on Linux) or Scheduled Tasks (on Windows)
-  that will be running every 5-15 minutes. This one task aggregates all required tasks
-  such as mail receiving, alerts evaluation etc. You should set up required parameters via
-  administration -> scheduled tasks.
-  Do not run this task under root, use same user that is used for web server.:
-
-  <bright>bundle exec rake easyproject:scheduler:run_tasks RAILS_ENV=production</bright>
-
-  For example:
-  1. Edit crontab
-    crontab -e
-
-  2. Add:
-    */15 * * * * cd #{base.redmine_root} && bundle exec rake easyproject:scheduler:run_tasks RAILS_ENV=production
-
-
-}
-  end
-end

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

@@ -1,26 +0,0 @@
-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/step.rb

@@ -1,16 +0,0 @@
-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'
-    autoload :EnvCheck,        'redmine-installer/steps/env_check'
-  end
-end

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

@@ -1,125 +0,0 @@
-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
-      # It could be dangerous
-      #
-      # if @database_backed_up
-      #   say(:restoring_database)
-      #   database_restore
-      # end
-    end
-
-    def final
-      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

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

@@ -1,79 +0,0 @@
-module Redmine::Installer::Step
-  ##
-  # Base
-  #
-  # == Steps:
-  # prepare::
-  #   used for argument validation
-  #
-  # up::
-  #   actions
-  #
-  # final::
-  #   for printing informations
-  #
-  # down::
-  #   if something went wrong
-  #
-  class Base
-
-    include Redmine::Installer::Utils
-
-    attr_accessor :index
-    attr_accessor :base
-    attr_accessor :ran
-
-    def initialize(index, base)
-      self.index = index
-      self.base = base
-      self.ran = false
-    end
-
-    def print_title
-      title  = '<bright><on_black><white>'
-      title << "#{index}. "
-      title << translate("step.#{self.class.class_name.underscore}.title"
-        )
-      title << '</white></on_black></bright>'
-
-      say(title, 1)
-    end
-
-    def print_header
-    end
-
-    def print_footer
-    end
-
-    def prepare
-    end
-
-    def up
-    end
-
-    def final
-    end
-
-    def down
-    end
-
-    def save(*)
-    end
-
-    def load(*)
-    end
-
-    def redmine_plugins
-      @redmine_plugins ||= _redmine_plugins
-    end
-
-    private
-
-      def _redmine_plugins
-        Dir.glob(File.join(base.redmine_root, 'plugins', '*')).select do |entry|
-          File.directory?(entry)
-        end
-      end
-
-  end
-end

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

@@ -1,15 +0,0 @@
-module Redmine::Installer::Step
-  class DatabaseConfig < Base
-
-    include Redmine::Installer::Helper::GenerateConfig
-
-    def up
-      if create_for(plugin::Database)
-        # continue
-      else
-        base.settings[:skip_migration] = true
-      end
-    end
-
-  end
-end

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

@@ -1,11 +0,0 @@
-module Redmine::Installer::Step
-  class EmailConfig < Base
-
-    include Redmine::Installer::Helper::GenerateConfig
-
-    def up
-      create_for(plugin::EmailSending)
-    end
-
-  end
-end

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

@@ -1,20 +0,0 @@
-module Redmine::Installer::Step
-  class EnvCheck < Base
-
-    def prepare
-      # Check if windows
-      # if windows?
-      #   confirm(:do_you_want_continue_if_windows, false)
-      # end
-
-      if root? && !confirm(:installer_run_as_root, false)
-        error(:terminated_by_user)
-      end
-    end
-
-    def up
-      say '<green>... OK</green>', 1
-    end
-
-  end
-end

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

@@ -1,23 +0,0 @@
-module Redmine::Installer::Step
-  class Install < Base
-
-    def up
-      Dir.chdir(base.tmp_redmine_root) do
-        command.bundle_install(base.env)
-
-        return if base.settings[:skip_migration]
-
-        command.rake_db_create(base.env)
-        command.rake_db_migrate(base.env)
-        command.rake_redmine_plugin_migrate(base.env) if some_plugins?
-        command.rake_generate_secret_token(base.env)
-
-        # Other plugins can have post-install procedure
-        plugin::RedminePlugin.all.each do |plugin|
-          plugin.install(base)
-        end
-      end
-    end
-
-  end
-end

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

@@ -1,226 +0,0 @@
-require 'rubygems/package'
-require 'ruby-progressbar'
-require 'fileutils'
-require 'net/http'
-require 'tmpdir'
-require 'zlib'
-require 'zip'
-require 'uri'
-
-module Redmine::Installer::Step
-  class LoadPackage < Base
-
-    SUPPORTED_ARCHIVE_FORMATS = ['.zip', '.gz', '.tgz']
-    TAR_LONGLINK = '././@LongLink'
-    PROGRESSBAR_FORMAT = '%a [%b>%i] %p%% %t'
-
-    def prepare
-      case base.options[:source]
-      when 'file'
-
-        unless File.exist?(base.package)
-          if base.package =~ /\Av?(\d\.\d\.\d)\Z/
-            download_redmine($1)
-          end
-        end
-
-        unless File.exist?(base.package)
-          error :file_not_exist, file: base.package
-        end
-
-        @type = File.extname(base.package)
-        unless SUPPORTED_ARCHIVE_FORMATS.include?(@type)
-          error :file_must_have_format, file: base.package, formats: SUPPORTED_ARCHIVE_FORMATS.join(', ')
-        end
-
-      when 'git'
-        nil
-      else
-        error :error_unsupported_source, source: base.options[:source]
-      end
-    end
-
-    def up
-      case base.options[:source]
-      when 'file'
-        load_from_archive
-      when 'git'
-        load_from_git
-      end
-    end
-
-    def down
-      FileUtils.remove_entry_secure(@tmpdir) if @tmpdir
-      FileUtils.safe_unlink(@tmpfile) if @tmpfile
-    end
-
-    def final
-      down
-      say(t(:redmine_was_installed_to, dir: base.redmine_root), 1)
-    end
-
-    private
-
-      # =======================================================================
-      # General
-
-      # Move files from temp dir to target. First check
-      # if folder contains redmine or contains
-      # folder which contains redmine :-)
-      #
-      # Package can have format:
-      # |-- redmine-2
-      #     |-- app
-      #     `-- config
-      # ...
-      #
-      def get_tmp_redmine_root
-        base.tmp_redmine_root = @tmpdir
-
-        loop {
-          ls = Dir.glob(File.join(base.tmp_redmine_root, '*'))
-
-          if ls.size == 1
-            base.tmp_redmine_root = ls.first
-          else
-            break
-          end
-        }
-      end
-
-
-      # =======================================================================
-      # File
-
-      def load_from_archive
-        # Make temp directory and extract archive + move it to the redmine_folder
-        extract_to_tmp
-
-        # Locate redmine_root in tmpdir
-        get_tmp_redmine_root
-      end
-
-      def download_redmine(version)
-        @tmpfile = Tempfile.new(['redmine', '.zip'])
-        @tmpfile.binmode
-
-        uri = URI("http://www.redmine.org/releases/redmine-#{version}.zip")
-
-        Net::HTTP.start(uri.host, uri.port) do |http|
-          head = http.request_head(uri)
-
-          unless head.is_a?(Net::HTTPSuccess)
-            error :cannot_download_redmine_version, version: version
-          end
-
-          say(:redmine_downloading, 1)
-          progressbar = ProgressBar.create(format: PROGRESSBAR_FORMAT, total: head['content-length'].to_i)
-
-          http.get(uri) do |data|
-            @tmpfile.write(data)
-            progressbar.progress += data.size
-          end
-
-          progressbar.finish
-          say(nil, 1)
-        end
-
-        @tmpfile.close
-
-        base.package = @tmpfile.path
-      end
-
-      def extract_to_tmp
-        @tmpdir = Dir.mktmpdir
-
-        case @type
-        when '.zip'
-          extract_zip
-        when '.gz', '.tgz'
-          extract_tar_gz
-        end
-      end
-
-      def extract_zip
-        Zip::File.open(base.package) do |zip_file|
-          # Progressbar
-          progressbar = ProgressBar.create(format: PROGRESSBAR_FORMAT, total: zip_file.size)
-
-          zip_file.each do |entry|
-            dest_file = File.join(@tmpdir, entry.name)
-            FileUtils.mkdir_p(File.dirname(dest_file))
-
-            entry.extract(dest_file)
-            progressbar.increment
-          end
-        end
-      end
-
-      # Extract .tar.gz archive
-      # based on http://dracoater.blogspot.cz/2013/10/extracting-files-from-targz-with-ruby.html
-      #
-      # Originally tar did not support paths longer than 100 chars. GNU tar is better and they
-      # implemented support for longer paths, but it was made through a hack called ././@LongLink.
-      # Shortly speaking, if you stumble upon an entry in tar archive which path equals to above
-      # mentioned ././@LongLink, that means that the following entry path is longer than 100 chars and
-      # is truncated. The full path of the following entry is actually the value of the current entry.
-      #
-      def extract_tar_gz
-        Gem::Package::TarReader.new(Zlib::GzipReader.open(base.package)) do |tar|
-
-          # Progressbar
-          progressbar = ProgressBar.create(format: PROGRESSBAR_FORMAT, total: tar.count)
-
-          # tar.count move position pointer to end
-          tar.rewind
-
-          dest_file = nil
-          tar.each do |entry|
-            if entry.full_name == TAR_LONGLINK
-              dest_file = File.join(@tmpdir, entry.read.strip)
-              next
-            end
-            dest_file ||= File.join(@tmpdir, entry.full_name)
-            if entry.directory?
-              FileUtils.rm_rf(dest_file) unless File.directory?(dest_file)
-              FileUtils.mkdir_p(dest_file, mode: entry.header.mode, verbose: false)
-            elsif entry.file?
-              FileUtils.rm_rf(dest_file) unless File.file?(dest_file)
-              File.open(dest_file, 'wb') do |f|
-                f.write(entry.read)
-              end
-              FileUtils.chmod(entry.header.mode, dest_file, verbose: false)
-            elsif entry.header.typeflag == '2' # symlink
-              File.symlink(entry.header.linkname, dest_file)
-            end
-
-            dest_file = nil
-            progressbar.increment
-          end
-        end
-      end
-
-
-      # =======================================================================
-      # Git
-
-      def load_from_git
-        @tmpdir = Dir.mktmpdir
-
-        # Package is remote url to git repository
-        remote = base.package
-
-        if remote
-          # Clone repository
-          Git.clone(remote, @tmpdir, base.options['branch'])
-        else
-          # Copy current repository to tmp and run pull
-          Git.copy_and_fetch(base.redmine_root, @tmpdir)
-        end
-
-        # Locate redmine_root in tmpdir
-        get_tmp_redmine_root
-      end
-
-  end
-end