redmine-installer 1.0.0

data/lib/redmine-installer/task.rb

@@ -0,0 +1,85 @@
+##
+# Parent for all commands (Install, Upgrade, Backup)
+#
+module Redmine::Installer
+  class Task
+
+    attr_accessor :redmine_root
+    attr_accessor :tmp_redmine_root
+    attr_accessor :options
+    attr_accessor :settings
+    attr_accessor :env
+
+    attr_reader :steps
+
+    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
+    end
+
+    def run
+      @steps.each do |id, step|
+        step.print_title
+        step.print_header
+        step.up
+        step.print_footer
+        step.ran = true
+        puts # new line
+      end
+
+      @steps.each do |id, step|
+        step.final_step
+      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
+
+      $stderr.puts(ANSI.red, e.message, ANSI.clear)
+      $stderr.flush
+      exit(1)
+    end
+
+    # 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
+    end
+
+    def self.step
+      Redmine::Installer::Step
+    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
+    end
+
+  end
+end

data/lib/redmine-installer/upgrade.rb

@@ -0,0 +1,68 @@
+##
+# 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
+
+    STEPS = [
+      step::RedmineRoot,
+      step::LoadPackage,
+      step::Validation,
+      step::Backup,
+      step::Upgrade,
+      step::MoveRedmine
+    ]
+
+    attr_accessor :package
+
+    def initialize(package, options={})
+      self.package = package
+      super(options)
+
+      check_package if options[:source] == 'file'
+    end
+
+    def run
+      Redmine::Installer::Profile.load(self, options[:profile])
+      super
+      Redmine::Installer::Profile.save(self) if options[:profile].nil?
+    end
+
+  end
+end

data/lib/redmine-installer/utils.rb

@@ -0,0 +1,233 @@
+require 'fileutils'
+require 'notifier'
+require 'ansi'
+
+module Redmine::Installer
+  module Utils
+    
+    def self.included(base)
+      base.send :extend,  Methods
+      base.send :include, Methods
+
+      base.class_eval do
+        self.send(:const_set, 'Git', Redmine::Installer::Git)
+      end
+    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
+
+
+      # =======================================================================
+      # 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
+        $stdin.gets.to_s.chomp
+      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
+
+        # 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}): "
+
+        $stdout.print(message)
+        answer = gets
+
+        return default if answer.empty?
+
+        if answer[0].downcase == yes[0].downcase
+          return true
+        else
+          return false
+        end
+      end
+
+
+      # =======================================================================
+      # Localizations
+
+      def translate(*args)
+        I18n.translate(*args)
+      end
+      alias_method :t, :translate
+
+
+      # =======================================================================
+      # Notifications
+
+      def notif(title, message=nil, image=nil)
+        return unless Redmine::Installer.config.notif
+
+        thread = ::Notifier.notify(
+          title: title.to_s,
+          message: message.to_s,
+          image: image.to_s
+        )
+        thread.join
+      end
+
+    end # Methods
+  end # Utils
+end # Redmine::Installer

data/lib/redmine-installer/version.rb

@@ -0,0 +1,5 @@
+module Redmine
+  module Installer
+    VERSION = '1.0.0'
+  end
+end

data/redmine-installer.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'redmine-installer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "redmine-installer"
+  spec.version       = Redmine::Installer::VERSION
+  spec.authors       = ["Ondřej Moravčík"]
+  spec.email         = ["moravcik.ondrej@gmail.com"]
+  spec.summary       = %q{Easy way how install/upgrade redmine or plugin.}
+  spec.description   = %q{Redmine-installer can fully install/upgrade redmine and will
+                       generate template for different server. All actions can be saved
+                       for further use.}
+  spec.homepage      = "https://github.com/ondra-m/redmine-installer"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+end

data/spec/lib/install_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+RSpec.describe Redmine::Installer::Install do
+
+  before(:example) do
+    @dir = Dir.mktmpdir
+  end
+
+  after(:example) do
+    FileUtils.remove_entry_secure(@dir)
+  end
+
+  let(:package1) { LoadRedmine.get('2.4.7') }
+
+  context 'mysql' do
+    let(:host)     { RSpec.configuration.mysql[:host] }
+    let(:port)     { RSpec.configuration.mysql[:port] }
+    let(:username) { RSpec.configuration.mysql[:username] }
+    let(:password) { RSpec.configuration.mysql[:password] }
+
+    before(:example) do
+      system("mysql -h #{host} --port #{port} -u #{username} -p#{password} -e 'drop database test1'")
+    end
+
+    it 'install' do
+      # redmine root -> temp dir
+      # type of db -> mysql
+      # database -> test1
+      # host -> configuration
+      # username -> configuration
+      # password -> configuration
+      # encoding -> utf8
+      # port -> configuration
+      # email configuration -> skip
+      # webserver -> skip
+
+      allow($stdin).to receive(:gets).and_return(
+        @dir, '1', 'test1', host, username, password, 'utf8', port, '999', '999'
+      )
+
+      r_installer = Redmine::Installer::Install.new(package1, {})
+      expect { r_installer.run }.to_not raise_error
+    end
+  end
+
+end