redmine-installer 1.0.7 → 2.0.0.rc1

data/lib/redmine-installer/spec/spec.rb

@@ -0,0 +1,81 @@
+# $stdin.sync = true
+# $stdout.sync = true
+
+# # require 'redmine-installer/spec/cursor'
+
+# class TestPrompt < TTY::Prompt
+
+#   def initialize(*args)
+#     # @input  = StringIO.new
+#     # @output = StringIO.new
+#     # super(input: @input, output: @output)
+#     super
+#     @pastel = Pastel.new(enabled: false)
+#   end
+
+# end
+
+# module RedmineInstaller
+
+#   # def self.prompt
+#   #   @prompt ||= TestPrompt.new
+#   # end
+
+#   def self.pastel
+#     @pastel ||= Pastel.new(enabled: false)
+#   end
+
+# end
+
+# module TTY
+#   module Cursor
+
+#     singleton_methods.each do |name|
+#       class_eval <<-METHODS
+
+#         def #{name}(*)
+#           ''
+#         end
+
+#         def self.#{name}(*)
+#           ''
+#         end
+
+#       METHODS
+#     end
+
+#   end
+# end
+
+$stdin.sync = true
+$stdout.sync = true
+
+module TTY::Cursor
+
+  singleton_methods.each do |name|
+    class_eval <<-METHODS
+
+      def #{name}(*)
+        ''
+      end
+
+      def self.#{name}(*)
+        ''
+      end
+
+    METHODS
+  end
+
+end
+
+class TestPrompt < TTY::Prompt
+
+  def initialize(*args)
+    super
+    @pastel = Pastel.new(enabled: false)
+  end
+
+end
+
+RedmineInstaller.instance_variable_set(:@prompt, TestPrompt.new)
+RedmineInstaller.instance_variable_set(:@pastel, Pastel.new(enabled: false))

data/lib/redmine-installer/task.rb

@@ -1,94 +1,35 @@
-##
-# Parent for all commands (Install, Upgrade, Backup)
-#
-module Redmine::Installer
+module RedmineInstaller
   class Task
+    include Utils
 
-    attr_accessor :redmine_root
-    attr_accessor :tmp_redmine_root
-    attr_accessor :options
-    attr_accessor :settings
-    attr_accessor :env
+    attr_reader :options
 
-    attr_reader :steps
+    def initialize(**options)
+      @options = OpenStruct.new(options)
 
-    def initialize(options={})
-      self.options = options
-      self.settings = {}
-      self.env = options[:env]
-
-      # Initialize steps for task
-      @steps = {}
-      index = 1
-      self.class::STEPS.each do |step|
-        @steps[index] = step.new(index, self)
-        index += 1
-      end
+      logger.info "#{class_name} initialized with #{options}"
+      logger.info "RUBY_VERSION: #{RUBY_VERSION}"
+      logger.info "USER: #{env_user}"
     end
 
     def run
-      @steps.each do |_, step|
-        step.prepare
-      end
-
-      @steps.each do |_, step|
-        step.print_title
-        step.print_header
-        step.up
-        step.print_footer
-        step.ran = true
-        puts
-      end
-
-      @steps.each do |_, step|
-        step.final
-      end
+      up
+    rescue => e
+      @error = e
 
-      Dir.chdir(redmine_root) do
-        Redmine::Installer::Plugin::RedminePlugin.all.each do |plugin|
-          plugin.final(self)
-        end
-      end
-    rescue Redmine::Installer::Error => e
-      # Rescue from error comes from installer
-      # run steps again for cleaning
-      @steps.values.reverse.each do |step|
-        next unless step.ran
-        step.down
-      end
+      logger.error(e.message)
+      logger.error(*e.backtrace)
 
-      $stderr.puts(ANSI.red, e.message, ANSI.clear)
-      $stderr.flush
-      exit(1)
-    end
+      puts pastel.red(e.message)
 
-    # Package is required for install task and
-    # upgrade with source file
-    def check_package
-      if package.nil?
-        raise Redmine::Installer::Error, I18n.translate(:error_argument_package_is_missing)
-      end
+      down
     end
 
-    def self.step
-      Redmine::Installer::Step
+    def up
+      raise NotImplementedError
     end
 
-    # Creating methods for recognition type of task
-    #
-    # == Examples:
-    #   class Install < Task
-    #   end
-    #
-    #   Install.new.install? #=> true
-    #
-    def self.inherited(child)
-      method_name = "#{child.class_name.downcase}?".to_sym
-
-      define_method(method_name) { false }
-      child.send(:define_method, method_name) { true }
-
-      super
+    def down
     end
 
   end

data/lib/redmine-installer/task_module.rb

@@ -0,0 +1,12 @@
+module RedmineInstaller
+  class TaskModule
+    include Utils
+
+    attr_reader :task
+
+    def initialize(task)
+      @task = task
+    end
+
+  end
+end

data/lib/redmine-installer/upgrade.rb

@@ -1,68 +1,60 @@
-##
-# Backup redmine
-#
-# You can upgrade current redmine by archive or currently defined git repository.
-# If your redmine contain plugins which are not part of new package - all these
-# plugins will be kept otherwise are replaced with those from package.
-#
-# Final step will ask you if you want save steps configuration.
-# If you say YES, configuration will be stored as profile so next time
-# you can upgrade redmine faster.
-#
-# redmine upgrade PACKAGE --profile PROFILE_ID
-# Profiles are stored on HOME_FOLDER/.redmine-installer-profiles.yml.
-#
-# == Steps:
-# 1. Redmine root - where should be new redmine located
-# 2. Load package - extract package
-# 3. Validation - current redmine should be valid
-# 4. Backup - backup current redmine (see backup section)
-# 5. Upgrading - install commands are executed
-# 6. Moving redmine - redmine is moved from temporarily folder to given redmine_root
-# 7. Profile saving - generating profile (see profile section)
-#
-# == Usage:
-#
-# From archive::
-#   # minimal
-#   redmine upgrade PATH_TO_PACKAGE
-#
-#   # full
-#   redmine upgrade PATH_TO_PACKAGE --env ENV1,ENV2,ENV3
-#
-# From git::
-#   # minimal
-#   redmine upgrade --source git
-#
-#   # full
-#   redmine upgrade --source git --env ENV1,ENV2,ENV3
-#
-module Redmine::Installer
-  class Upgrade < Task
+module RedmineInstaller
+  class Upgrade < Install
 
-    STEPS = [
-      step::EnvCheck,
-      step::RedmineRoot,
-      step::LoadPackage,
-      step::Validation,
-      step::Backup,
-      step::Upgrade,
-      step::MoveRedmine
-    ]
+    def up
+      if options.profile
+        @profile = Profile.get!(options.profile)
+      end
 
-    attr_accessor :package
+      if @profile
+        @target_redmine.load_profile(@profile)
+      end
 
-    def initialize(package, options={})
-      self.package = package
-      super(options)
+      @environment.check
+      @target_redmine.ensure_and_valid_root
+      @target_redmine.validate
+      @target_redmine.check_running_state
 
-      check_package if options[:source] == 'file'
+      @package.ensure_and_valid_package
+      @package.extract
+
+      @temp_redmine.root = @package.redmine_root
+
+      @target_redmine.make_backup
+
+      @temp_redmine.copy_importants_from(@target_redmine)
+      @temp_redmine.copy_missing_plugins_from(@target_redmine)
+
+      @temp_redmine.upgrade
+
+      print_title('Finishing installation')
+      ok('Cleaning root'){ @target_redmine.delete_root }
+      ok('Moving redmine to target directory'){ @target_redmine.move_from(@temp_redmine) }
+      ok('Cleanning up'){ @package.clean_up }
+      ok('Moving installer log'){ logger.move_to(@target_redmine, suffix: 'upgrade') }
+
+      puts
+      puts pastel.bold('Redmine was upgraded')
+      logger.info('Redmine was upgraded')
+
+      if @profile.nil? && prompt.yes?('Do you want save steps for further use?', default: false)
+        profile = Profile.new
+        @target_redmine.save_profile(profile)
+        profile.save
+      end
     end
 
-    def run
-      Redmine::Installer::Profile.load(self, options[:profile])
-      super
-      Redmine::Installer::Profile.save(self) if options[:profile].nil?
+    def down
+      @temp_redmine.clean_up
+      @package.clean_up
+
+      if @target_redmine.database && @target_redmine.database.backuped?
+        puts
+        puts "Database have been backed up on #{pastel.bold(@target_redmine.database.backup)}"
+      end
+
+      puts
+      puts "(Log is located on #{pastel.bold(logger.path)})"
     end
 
   end

data/lib/redmine-installer/utils.rb

@@ -1,248 +1,61 @@
-require 'fileutils'
-require 'notifier'
-require 'ansi'
-require 'io/console'
-
-module Redmine::Installer
+module RedmineInstaller
   module Utils
 
-    def self.included(base)
-      base.send :extend,  Methods
-      base.send :include, Methods
+    PROGRESSBAR_FORMAT = ':elapsed [:bar] :percent'
 
-      base.class_eval do
-        self.send(:const_set, 'Git', Redmine::Installer::Git)
-      end
+    def class_name
+      self.class.name.split('::').last
     end
 
-    module Methods
-
-      # =======================================================================
-      # Generals
-
-      def plugin
-        Redmine::Installer::Plugin
-      end
-
-      def command
-        Redmine::Installer::Command.instance
-      end
-
-      def error(*args)
-        # Translate message
-        if args.first.is_a?(Symbol)
-          message = translate(*args)
-        else
-          message = args.first
-        end
-
-        # Colorize message
-        colorize(message)
-
-        raise Redmine::Installer::Error, message
-      end
-
-      # Try create a dir
-      # When mkdir raise an error (permission problem) method
-      # ask user if wants exist or try again
-      def try_create_dir(dir)
-        begin
-          FileUtils.mkdir_p(dir)
-        rescue
-          choices = {}
-          choices[:exit] = t(:exit)
-          choices[:try_again] = t(:try_again)
-
-          answer = choose(t(:dir_not_exist_and_cannot_be_created, dir: dir), choices, default: :exit)
-
-          case answer
-          when :exit
-            error ''
-          when :try_again
-            try_create_dir(dir)
-          end
-        end
-      end
-
-      # Check if there are plugins in plugin dir
-      def some_plugins?
-        Dir.glob(File.join('plugins', '*')).select{|record| File.directory?(record)}.any?
-      end
-
-      def windows?
-        RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
-      end
-
-      def root?
-        Process.euid == 0
-      end
-
-
-      # =======================================================================
-      # Input, output
-
-      # Print message to stdout
-      def say(message, lines=0)
-        # Translate message
-        if message.is_a?(Symbol)
-          message = translate(message)
-        end
-
-        # Colorize message
-        colorize(message)
-
-        $stdout.print(message)
-        lines.times { $stdout.puts }
-        $stdout.flush
-      end
-
-      # Colorize text based on XML marks
-      #
-      # == Examples:
-      #   colorize("<bright><on_black><white>text</white></on_black></bright>")
-      #   # => "\e[1m\e[40m\e[37mtext\e[0m\e[0m\e[0m"
-      #
-      def colorize(text)
-        return unless text.is_a?(String)
-
-        text.gsub!(/<([a-zA-Z0-9_]+)>/) do
-          if ANSI::CHART.has_key?($1.to_sym)
-            ANSI.send($1)
-          else
-            "<#{$1}>"
-          end
-        end
-        text.gsub!(/<\/([a-zA-Z0-9_]+)>/) do
-          if ANSI::CHART.has_key?($1.to_sym)
-            ANSI.clear
-          else
-            "</#{$1}>"
-          end
-        end
-      end
-
-      # Instead of `super` take only what I need
-      def gets(hide=false)
-        if hide
-          input = $stdin.noecho{|io| io.gets}.to_s.chomp
-          $stdout.puts # noecho is also for enter
-          input
-        else
-          $stdin.gets.to_s.chomp
-        end
-      end
-
-      # Asking on 1 line
-      def ask(message=nil, options={})
-        # Translate message
-        if message.is_a?(Symbol)
-          message = translate(message)
-        end
-        default = options[:default]
-
-        if default
-          message << " [#{default}]"
-        end
-
-        if !options[:without_colon]
-          message << ': '
-        end
-
-        say(message)
-        input = gets(options[:hide])
-
-        # Ctrl-D or enter was pressed
-        return default if input.empty?
-
-        input
-      end
-
-      # User can choose from selection
-      def choose(message, choices, options={})
-        choices = choices.to_a
-        default = options[:default]
-        index = 1
-
-        say(message, 1) unless message.nil?
-        choices.each do |(key, message)|
-          if key == default
-            pre = '*'
-          else
-            pre = ' '
-          end
-
-          say(" #{pre}#{index}) #{message}", 1)
-          index += 1
-        end
-
-        input = ask('> ', without_colon: true).to_i
-        puts
-
-        # Without default is input 0
-        return default if input.zero? || input > choices.size
-
-        choices[input-1][0]
-      end
-
-      # Say 'Do you want?'
-      # -> YES, NO
-      #
-      def confirm(message, default=true)
-        # Translate message
-        if message.is_a?(Symbol)
-          message = translate(message)
-        end
-
-        # Colorize message
-        colorize(message)
-
-        yes = t(:yes_t)
-        no  = t(:no_t)
-
-        if default
-          yes.upcase!
-        else
-          no.upcase!
-        end
-
-        message << " (#{yes}/#{no}): "
+    def logger
+      RedmineInstaller.logger
+    end
 
-        $stdout.print(message)
-        answer = gets
+    def prompt
+      RedmineInstaller.prompt
+    end
 
-        return default if answer.empty?
+    def pastel
+      RedmineInstaller.pastel
+    end
 
-        if answer[0].downcase == yes[0].downcase
-          return true
-        else
-          return false
-        end
-      end
+    def run_command(cmd, title=nil)
+      RedmineInstaller::Command.new(cmd, title: title).run
+    end
 
+    def ok(title)
+      print "#{title} ... "
+      yield
+      puts pastel.green('OK')
+    rescue => e
+      puts pastel.red('FAIL')
+      raise
+    end
 
-      # =======================================================================
-      # Localizations
+    def env_user
+      ENV['USER'] || ENV['USERNAME']
+    end
 
-      def translate(*args)
-        I18n.translate(*args)
+    # Try create a dir
+    # When mkdir raise an error (permission problem) method ask user if wants exist or try again
+    def create_dir(dir)
+      FileUtils.mkdir_p(dir)
+    rescue
+      if prompt.yes?("Dir #{dir} doesn't exist and can't be created. Try again?", default: true)
+        create_dir(dir)
+      else
+        error('Dir creating was aborted by user.')
       end
-      alias_method :t, :translate
-
-
-      # =======================================================================
-      # Notifications
+    end
 
-      def notif(title, message=nil, image=nil)
-        return unless Redmine::Installer.config.notif
+    def print_title(title)
+      puts
+      puts pastel.white.on_black(title)
+    end
 
-        thread = ::Notifier.notify(
-          title: title.to_s,
-          message: message.to_s,
-          image: image.to_s
-        )
-        thread.join
-      end
+    def error(message)
+      raise RedmineInstaller::Error, message
+    end
 
-    end # Methods
-  end # Utils
-end # Redmine::Installer
+  end
+end