redmine-installer 1.0.0

data/lib/redmine-installer/cli.rb

@@ -0,0 +1,90 @@
+require 'gli'
+
+module Redmine::Installer
+  class CLI
+    extend GLI::App
+
+    def self.spec
+      @spec ||= Gem::Specification::load('redmine-installer.gemspec')
+    end
+
+    def self.start(argv)
+      # Program settings
+      program_desc I18n.translate(:redmine_installer_summary)
+      version Redmine::Installer::VERSION
+
+      # Global options
+
+      # Verbose
+      desc I18n.translate(:cli_show_verbose_output)
+      default_value false
+      switch [:d, :v, :debug, :verbose], negatable: false
+
+      # Locale
+      default_value 'en'
+      flag [:l, :locale]
+
+      # Before all action
+      pre do |global_options, command, options, args|
+        $verbose = global_options[:debug]
+        I18n.locale = global_options[:locale]
+        true
+      end
+
+      # Install command
+      desc I18n.translate(:cli_install_desc)
+      arg :package
+      command [:i, :install] do |c|
+        c.flag [:s, :source], default_value: 'file',
+                              must_match: ['file', 'git'],
+                              desc: I18n.translate(:cli_flag_source)
+
+        c.flag [:b, :branch], default_value: 'master',
+                              desc: I18n.translate(:cli_flag_branch)
+
+        c.flag [:e, :env, :environment], default_value: ['production'],
+                                         desc: I18n.translate(:cli_flag_environment),
+                                         type: Array
+
+        c.action do |global_options, options, args|
+          run_action('install', args.first, options)
+        end
+      end
+
+      # Upgrade command
+      desc I18n.translate(:cli_upgrade_desc)
+      arg :package
+      command [:u, :upgrade] do |c|
+        c.flag [:p, :profile]
+        c.flag [:s, :source], default_value: 'file',
+                              must_match: ['file', 'git'],
+                              desc: I18n.translate(:cli_flag_source)
+
+        c.flag [:e, :env, :environment], default_value: ['production'],
+                                         desc: I18n.translate(:cli_flag_environment),
+                                         type: Array
+
+        c.action do |global_options, options, args|
+          run_action('upgrade', args.first, options)
+        end
+      end
+
+      # Backup command
+      desc I18n.translate(:cli_backup_desc)
+      arg :redmine_root
+      command [:b, :backup] do |c|
+        c.flag [:p, :profile]
+        c.action do |global_options, options, args|
+          run_action('backup', args.first, options)
+        end
+      end
+
+      run(argv)
+    end
+
+    def self.run_action(action, *args)
+      Redmine::Installer.const_get(action.capitalize).new(*args).run
+    end
+
+  end
+end

data/lib/redmine-installer/command.rb

@@ -0,0 +1,142 @@
+require 'singleton'
+
+module Redmine::Installer
+  class Command
+    include Singleton
+    include Redmine::Installer::Utils
+
+    RAKE = 'bundle exec rake'
+
+    def bundle_install(env)
+      run('bundle install', get_bundle_env(env), :'command.bundle_install')
+    end
+
+    def rake_db_create(env)
+      run(RAKE, 'db:create', get_rails_env(env), :'command.rake_db_create')
+    end
+
+    def rake_db_migrate(env)
+      run(RAKE, 'db:migrate', get_rails_env(env), :'command.rake_db_migrate')
+    end
+
+    def rake_redmine_plugin_migrate(env)
+      run(RAKE, 'redmine:plugins:migrate', get_rails_env(env), :'command.rake_redmine_plugin_migrate')
+    end
+
+    def rake_generate_secret_token(env)
+      run(RAKE, 'generate_secret_token', get_rails_env(env), :'command.rake_generate_secret_token')
+    end
+
+    private
+
+      def run(*args)
+        _args = args.dup
+
+        # Last element is title
+        title = args.pop
+        title = translate(title) if title.is_a?(Symbol)
+        title = "--> <yellow>#{title}</yellow>"
+        colorize(title)
+
+        command = args.join(' ')
+
+        puts '-->'
+        puts title
+        puts '-->'
+        success = Kernel.system(command)
+
+        unless success
+          if confirm(:do_you_want_repeat_command, false)
+            return run(*_args)
+          end
+        end
+
+        return success
+      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
+      end
+
+      def get_bundle_env(env)
+        if env.include?('production')
+          '--without development test'
+        else
+          ''
+        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/config_param.rb

@@ -0,0 +1,90 @@
+##
+# Class for easyier handle configuration parameters
+#
+# == Examples:
+#
+#   params = Redmine::Installer::ConfigParams.new
+#   params.add('database')
+#   params.add('host').note('this is a host').default('localhost')
+#
+module Redmine::Installer
+  class ConfigParams
+    def initialize
+      @params = []
+    end
+
+    def [](key)
+      @params.detect{|p| p.name == key}
+    end
+
+    def for_asking
+      @for_asking ||= @params.select{|p| p.ask}
+    end
+
+    def add(name)
+      param = ConfigParam.new(name)
+      @params << param
+      param
+    end
+
+    def each(&block)
+      @params.each(&block)
+    end
+
+    def map(&block)
+      @params.map(&block)
+    end
+  end
+
+  class ConfigParam
+
+    @@attributes = []
+
+    def self.attribute(name, default=nil)
+      eval <<-EVAL
+        def #{name}(value=nil)
+          return @#{name} if value.nil?
+          self.#{name} = value
+        end
+
+        def #{name}=(value)
+          @#{name} = value
+        end
+      EVAL
+
+      @@attributes << [name, default]
+    end
+
+    attribute :name
+    attribute :note
+    attribute :default
+    attribute :value
+    attribute :ask, true
+
+    def initialize(name)
+      # Default
+      @@attributes.each{|(k,v)| set(k,v)}
+
+      set(:name, name)
+    end
+
+    # Return string for print
+    def title
+      out = name.capitalize
+      out << " (#{note})" if note
+      out
+    end
+
+    def set(key, value)
+      self.send("#{key}=", value)
+    end
+
+    def default(value=nil)
+      return @default if value.nil?
+
+      self.default = value
+      self.value = value if self.value.nil?
+    end
+
+  end
+end

data/lib/redmine-installer/error.rb

@@ -0,0 +1,5 @@
+module Redmine::Installer
+  # Package does not exist
+  class Error < StandardError
+  end
+end

data/lib/redmine-installer/exec.rb

@@ -0,0 +1,158 @@
+require 'open3'
+
+##
+# Executions commands with timer and error handling
+#
+module Redmine::Installer
+  class Exec
+
+    include Redmine::Installer::Utils
+
+    REFRESH_TIMER = 1 # in s
+
+    attr_reader :stdout, :stderr
+
+    def initialize(command, title=nil, timer=true)
+      @command = command
+
+      with_title(title)
+      with_timer(timer)
+    end
+
+    def with_title(title)
+      if title.is_a?(Symbol)
+        title = I18n.translate(title)
+      end
+
+      @title = title
+      self
+    end
+
+    def with_timer(yes_no)
+      if $stdout.tty?
+        @with_timer = yes_no
+      else
+        @with_timer = false
+      end
+      self
+    end
+
+    def run(repeatable=false)
+      show_title
+
+      Open3.popen3(@command) do |stdin, stdout, stderr, wait_thr|
+        # log = StringIO.new
+        # redirect_stream(stdout, log)
+        # redirect_stream(stderr, log)
+
+        # For example: rake db:create can ask for root login
+        # if current setting does not work
+        # stdin.closes
+
+        exit_status = wait_thr.value
+        @stdout = stdout.read
+        @stderr = stderr.read
+
+        stop_timer
+        if exit_status.success?
+          print_result(true)
+          @return_value = true
+        else
+          print_result(false)
+          @return_value = false
+          # raise Redmine::Installer::Error, stderr.read
+        end
+      end
+
+      unless success
+        # print_error
+        if repeatable && repeat?
+          return run(repeatable)
+        end
+      end
+
+      return success
+    ensure
+      # stop_timer
+    end
+
+    private
+
+      def print_error
+        message = '<red>'
+        message << '--------------------------------------------------------------'
+        message << "\n"
+        message << stderr
+        message << '--------------------------------------------------------------'
+        message << '</red>'
+        colorize(message)
+        
+        $stderr.puts(message)
+        $stderr.flush
+      end
+
+      def repeat?
+        confirm(:do_you_want_repeat_command, false)
+      end
+
+      def show_title
+        if @with_timer
+          @timer = start_timer
+        else
+          $stdout.print(@title)
+        end
+      end
+
+      def start_timer
+        Thread.new do
+          counter = 0
+
+          loop {
+            hours, seconds = counter.divmod(3600)
+            minutes, seconds = seconds.divmod(60)
+
+            printf "[%02d:%02d:%02d] %s\r", hours, minutes, seconds, @title
+            counter += REFRESH_TIMER
+            sleep(REFRESH_TIMER)
+          }
+        end
+      end
+
+      def stop_timer
+        if @timer
+          @timer.kill
+
+          # Clean line
+          print ' ' * 100
+          print "\r"
+        end
+      end
+
+      def print_result(ok=true)
+        if ok
+          out = $stdout
+          message = '... OK'
+        else
+          out = $stderr
+          message = '... FAIL'
+        end
+
+        if @with_timer
+          out.puts("#{@title} #{message}")
+        else
+          out.print(message)
+        end
+
+        out.flush
+      end
+
+      def redirect_stream(stream, out)
+        Thread.new do
+          while (line = stream.gets)
+            out.puts(line)
+          end
+        end
+      end
+
+  end
+end