redmine-installer 1.0.7 → 2.0.0.rc1

data/lib/redmine-installer/environment.rb

@@ -0,0 +1,21 @@
+module RedmineInstaller
+  class Environment < TaskModule
+
+    def check
+      if user_is_root? && !task.options.enable_user_root
+        error 'You cannot install redmine under root. Please change user.'
+      end
+
+      if Gem::Version.new(RUBY_VERSION) < Gem::Version.new(RedmineInstaller::MIN_SUPPORTED_RUBY)
+        error "You are using unsupported ruby. Please install at least #{RedmineInstaller::MIN_SUPPORTED_RUBY}."
+      end
+
+      logger.info 'Environemnt checked'
+    end
+
+    def user_is_root?
+      Process.euid == 0
+    end
+
+  end
+end

data/lib/redmine-installer/errors.rb

@@ -0,0 +1,7 @@
+module RedmineInstaller
+  class Error < StandardError
+  end
+
+  class ProfileError < Error
+  end
+end

data/lib/redmine-installer/install.rb

@@ -1,50 +1,45 @@
-##
-# Install redmine
-#
-# You can instal redmine package from archive or git.
-#
-# == Steps:
-# 1. Redmine root - where should be new redmine located
-# 2. Load package - extract package
-# 3. Database configuration - you can choose type of DB which you want to use
-# 4. Email sending configuration - email sending configuration
-# 5. Install - install commands are executed
-# 6. Moving redmine - redmine is moved from temporarily folder to given redmine_root
-# 7. Webserve configuration - generating webserver configuration
-#
-# == Usage:
-#
-# From archive::
-#   Supported archives are .zip and .tar.gz.
-#
-#   # minimal
-#   redmine install PATH_TO_PACKAGE
-#   redmine install REDMINE_VERSION
-#
-#   # full
-#   redmine install PATH_TO_PACKAGE --env ENV1,ENV2,ENV3
-#
-module Redmine::Installer
+module RedmineInstaller
   class Install < Task
 
-    STEPS = [
-      step::EnvCheck,
-      step::RedmineRoot,
-      step::LoadPackage,
-      step::DatabaseConfig,
-      step::EmailConfig,
-      step::Install,
-      step::MoveRedmine,
-      step::WebserverConfig
-    ]
+    def initialize(package, redmine_root, **options)
+      super(**options)
 
-    attr_accessor :package
+      @environment = Environment.new(self)
+      @package = Package.new(self, package)
+      @target_redmine = Redmine.new(self, redmine_root)
+      @temp_redmine = Redmine.new(self)
+    end
+
+    def up
+      @temp_redmine.valid_options
+      @environment.check
+      @target_redmine.ensure_and_valid_root
+      @package.ensure_and_valid_package
+      @package.extract
+
+      @temp_redmine.root = @package.redmine_root
+
+      @temp_redmine.create_database_yml
+      @temp_redmine.create_configuration_yml
+      @temp_redmine.install
+
+      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: 'install') }
+
+      puts
+      puts pastel.bold('Redmine was installed')
+      logger.info('Redmine was installed')
+    end
 
-    def initialize(package, options={})
-      self.package = package
-      super(options)
+    def down
+      @temp_redmine.clean_up
+      @package.clean_up
 
-      check_package
+      puts
+      puts "(Log is located on #{pastel.bold(logger.path)})"
     end
 
   end

data/lib/redmine-installer/logger.rb

@@ -0,0 +1,83 @@
+require 'digest'
+
+module RedmineInstaller
+  class Logger
+
+    def self.verify(log_file)
+      log_file = log_file.to_s
+
+      unless File.exist?(log_file)
+        puts "File '#{log_file}' does not exist."
+        exit(false)
+      end
+
+      content = File.open(log_file, &:to_a)
+      digest1 = content.pop
+      digest2 = Digest::SHA256.hexdigest(content.join)
+
+      if digest1 == digest2
+        puts RedmineInstaller.pastel.green("Logfile is OK. Digest verified.")
+      else
+        puts RedmineInstaller.pastel.red("Logfile is not OK. Digest wasn't verified.")
+      end
+    end
+
+    def initialize
+      if ENV['REDMINE_INSTALLER_LOGFILE']
+        @output = File.open(ENV['REDMINE_INSTALLER_LOGFILE'], 'w')
+      else
+        @output = Tempfile.create('redmine_installer.log')
+      end
+    end
+
+    def path
+      @output.path
+    end
+
+    def finish
+      close
+      digest = Digest::SHA256.file(path).hexdigest
+      File.open(path, 'a') { |f| f.write(digest) }
+    end
+
+    def close
+      @output.flush
+      @output.close
+    end
+
+    def move_to(redmine, suffix: '%d%m%Y_%H%M%S')
+      close
+
+      new_path = File.join(redmine.log_path, Time.now.strftime("redmine_installer_#{suffix}.log"))
+
+      FileUtils.mkdir_p(redmine.log_path)
+      FileUtils.mv(path, new_path)
+      @output = File.open(new_path, 'a+')
+    end
+
+    def info(*messages)
+      log(' INFO', *messages)
+    end
+
+    def error(*messages)
+      log('ERROR', *messages)
+    end
+
+    def warn(*messages)
+      log(' WARN', *messages)
+    end
+
+    def std(*messages)
+      log('  STD', *messages)
+    end
+
+    def log(severity, *messages)
+      messages.each do |message|
+        @output.puts("#{severity}: #{message}")
+      end
+
+      @output.flush
+    end
+
+  end
+end

data/lib/redmine-installer/package.rb

@@ -0,0 +1,180 @@
+require 'rubygems/package'
+require 'net/http'
+require 'zlib'
+require 'uri'
+
+module RedmineInstaller
+  class Package < TaskModule
+
+    SUPPORTED_ARCHIVE_FORMATS = ['.zip', '.gz', '.tgz']
+    TAR_LONGLINK = '././@LongLink'
+
+    attr_reader :package
+
+    def initialize(task, package)
+      super(task)
+      @package = package.to_s
+    end
+
+    def ensure_and_valid_package
+      if package.empty?
+        @package = prompt.ask('Path to package:', required: true)
+      end
+
+      if !File.exist?(@package)
+        if @package =~ /\Av?(\d\.\d\.\d)\Z/
+          @package = download_redmine($1)
+        else
+          error "File doesn't exist #{@package}"
+        end
+      end
+
+      @type = File.extname(@package)
+      unless SUPPORTED_ARCHIVE_FORMATS.include?(@type)
+        error "File #{@package} must have format: #{SUPPORTED_ARCHIVE_FORMATS.join(', ')}"
+      end
+    end
+
+    def extract
+      print_title('Extracting redmine package')
+
+      @temp_dir = Dir.mktmpdir
+
+      case @type
+      when '.zip'
+        extract_zip
+      when '.gz', '.tgz'
+        extract_tar_gz
+      end
+
+      logger.info("Package was loaded into #{@temp_dir}.")
+    end
+
+    # 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 redmine_root
+      root = @temp_dir
+
+      loop {
+        ls = Dir.glob(File.join(root, '*'))
+
+        if ls.size == 1
+          root = ls.first
+        else
+          break
+        end
+      }
+
+      root
+    end
+
+    def clean_up
+      @temp_dir && FileUtils.remove_entry_secure(@temp_dir)
+      @temp_file && FileUtils.remove_entry_secure(@temp_file)
+    end
+
+    private
+
+      def download_redmine(version)
+        @temp_file = Tempfile.new(['redmine', '.zip'])
+        @temp_file.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}"
+          end
+
+          print_title("Downloading redmine #{version}")
+          progressbar = TTY::ProgressBar.new(PROGRESSBAR_FORMAT, total: head['content-length'].to_i, frequency: 2, clear: true)
+
+          http.get(uri) do |data|
+            @temp_file.write(data)
+            progressbar.advance(data.size)
+          end
+
+          progressbar.finish
+        end
+
+        logger.info("Redmine #{version} downloaded")
+
+        @temp_file.close
+        @temp_file.path
+      end
+
+      def extract_zip
+        Zip::File.open(@package) do |zip_file|
+          # Progressbar
+          progressbar = TTY::ProgressBar.new(PROGRESSBAR_FORMAT, total: zip_file.size, frequency: 2, clear: true)
+
+          zip_file.each do |entry|
+            dest_file = File.join(@temp_dir, entry.name)
+            FileUtils.mkdir_p(File.dirname(dest_file))
+
+            entry.extract(dest_file)
+            progressbar.advance(1)
+          end
+
+          progressbar.finish
+        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(@package)) do |tar|
+
+          # Progressbar
+          progressbar = TTY::ProgressBar.new(PROGRESSBAR_FORMAT, total: tar.count, frequency: 2, clear: true)
+
+          # 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(@temp_dir, entry.read.strip)
+              next
+            end
+            dest_file ||= File.join(@temp_dir, 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.advance(1)
+          end
+
+          progressbar.finish
+        end
+      end
+
+  end
+end

data/lib/redmine-installer/patches/ruby.rb

@@ -0,0 +1,35 @@
+class Object
+
+  def blank?
+    false
+  end
+
+  def present?
+    true
+  end
+
+end
+
+class String
+
+  def blank?
+    empty?
+  end
+
+  def present?
+    !blank?
+  end
+
+end
+
+class NilClass
+
+  def blank?
+    true
+  end
+
+  def present?
+    false
+  end
+
+end

data/lib/redmine-installer/patches/tty.rb

@@ -0,0 +1,16 @@
+# module TTY
+#   class ProgressBar
+#     # Every progressbar register new signal handlers
+#     def register_signals
+#     end
+#   end
+# end
+
+# module TTY
+#   class Prompt
+#     class List
+#       def keyescape(*)
+#       end
+#     end
+#   end
+# end

data/lib/redmine-installer/profile.rb

@@ -1,73 +1,42 @@
-require 'fileutils'
+require 'ostruct'
 require 'yaml'
 
-module Redmine::Installer
-  class Profile
+module RedmineInstaller
+  class Profile < OpenStruct
+    PROFILES_FILE = File.join(Dir.home, '.redmine-installer-profiles.yml')
 
-    include Redmine::Installer::Utils
+    def self.get!(profile_id)
+      data = YAML.load_file(PROFILES_FILE) rescue nil
 
-    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)
+      if data.is_a?(Hash) && data.has_key?(profile_id)
+        Profile.new(profile_id, data[profile_id])
+      else
+        raise RedmineInstaller::ProfileError, "Profile ID=#{profile_id} does not exist"
+      end
     end
 
-    attr_accessor :task
-
-    def initialize(task)
-      self.task = task
+    attr_reader :id
 
-      # 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
+    def initialize(id=nil, data={})
+      super(data)
+      @id = id
     end
 
     def save
-      # All steps save configuration which can be use again
-      configuration = {}
-      task.steps.each do |_, step|
-        step.save(configuration)
-      end
+      FileUtils.touch(PROFILES_FILE)
 
-      @data[id] = configuration
+      all_data = YAML.load_file(PROFILES_FILE)
+      all_data = {} unless all_data.is_a?(Hash)
 
-      File.open(CONFIG_FILE, 'w') {|f| f.puts(YAML.dump(@data))}
-    end
-
-    def load(id)
-      @id = id.to_i
+      @id ||= all_data.keys.last.to_i + 1
 
-      configuration = @data[@id]
+      all_data[@id] = to_h
 
-      return {} if configuration.nil?
-
-      task.steps.each do |_, step|
-        step.load(configuration)
-      end
+      File.write(PROFILES_FILE, YAML.dump(all_data))
 
-      return configuration
+      puts "Profile was saved under ID=#{@id}"
+    rescue => e
+      puts "Profile could not be save due to #{e.message}"
     end
 
   end