luban 0.2.0

data/lib/luban/deployment/cli/package/installer/install.rb

@@ -0,0 +1,330 @@
+module Luban
+  module Deployment
+    module Package
+      class Installer
+        class InstallFailure < Luban::Deployment::Error; end
+
+        def required_packages
+          @required_packages ||= 
+            self.class.package_class(package_name).
+              required_packages_for(package_major_version)
+        end
+
+        def configure_executable
+          @configure_executable ||= './configure'
+        end
+
+        def installed?
+          raise NotImplementedError, "#{self.class.name}#installed? is an abstract method."
+        end
+
+        def validate_download_url
+          info "Validating download URL for #{package_full_name}"
+          validate_download_url!
+        end
+
+        def install
+          info "Installing #{package_full_name}"
+          if installed?
+            if force?
+              install!
+            else
+              update_result "Skipped! #{package_full_name} has been installed ALREADY.", 
+                            status: :skipped
+              return
+            end
+          else
+            install!
+          end
+
+          if installed?
+            update_result "Successfully installed #{package_full_name}."
+          else
+            update_result "Failed to install #{package_full_name}. " +
+                          "Please check install log for details: #{install_log_file_path}",
+                          status: :failed, level: :error
+          end
+        end
+
+        def uninstall
+          info "Uninstalling #{package_full_name}"
+          if installed?
+            if current? and !force?
+              update_result "Skippped! #{package_full_name} is the current version in use. " +
+                            "Please switch to other version before uninstalling this version or " +
+                            "use -f to force uninstalling.",
+                            status: :skipped, level: :warn
+            else
+              uninstall!
+              update_result "#{package_full_name} is uninstalled. "
+            end
+          else
+            message = "#{package_full_name} is NOT installed.",
+            if directory?(install_path) or directory?(build_path)
+              if force?
+                uninstall!
+                update_result message + 
+                              "Cleaned up leftover of #{package_full_name} from last installation."
+              else
+                update_result message +
+                              "But leftover from last installation is found. " +
+                              "Use -f to force clean it up."
+              end
+            else
+              update_result "Skipped! #{message}"
+            end
+          end
+        end
+
+        def cleanup_all
+          cleanup_temp!
+          cleanup_logs!
+          update_result "Cleaned up temporary files in #{package_full_name} installation"
+        end
+
+        def get_summary
+          status = if current_symlinked?
+                     current? ? " *" : "s*"
+                   else
+                     current? ? "c*" : "  "
+                    end
+
+          if installed?
+            installed = '(installed)'
+            alert = case status
+                    when "s*"
+                      "Alert! #{package_full_name} is not the current version but symlinked IMPROPERLY. " +
+                      "Run \"binstubs\" to fix it."
+                    when "c*"
+                      "Alert! #{package_full_name} is set as current version but NOT symlinked properly. " +
+                      "Run \"binstubs\" to fix it."
+                    end
+          else
+            installed = '(NOT installed)'
+            alert = nil
+          end
+          update_result summary: { name: package_full_name, installed: installed, 
+                                   status: status, alert: alert }
+        end
+
+        def update_binstubs
+          if current?
+            if installed?
+              update_binstubs!
+              update_result "Updated #{package_name} binstubs with current version #{package_version}"
+            else
+              update_result "Skipped! #{package_full_name} is NOT installed yet. Please install it first.",
+                            status: :failed, level: :error
+            end
+          else
+            if current_symlinked?
+              remove_binstubs!
+              remove_symlinks!
+              update_result "Removed #{package_name} binstubs with version #{package_version}. " +
+                            "Current version of #{package_name} is NOT specified.",
+                            level: :warn
+            end
+          end
+        end
+
+        def which_current
+          get_summary
+          task.result.summary[:executable] = "Not found"
+          if current? and current_symlinked? and
+             file?(executable = File.join(readlink(current_path), 'bin', task.args.executable))
+            task.result.summary[:executable] = executable
+          end
+        end
+
+        def whence_origin
+          get_summary
+          task.result.summary[:executable] = "Not found"
+          if file?(executable = bin_path.join(task.args.executable))
+            task.result.summary[:executable] = executable
+          end
+        end
+
+        protected
+
+        def before_install
+          bootstrap
+          unless installed? or file?(src_file_path)
+            validate_download_url
+          end
+          install_required_packages(:before_install)          
+        end
+
+        def after_install
+          install_required_packages(:after_install)
+          update_binstubs!
+        end
+
+        def install_required_packages(type)
+          required_packages[type].each do |d|
+            self.class.worker_class(:installer, package: d.name).new(
+              config: config, backend: backend, 
+              cmd: :install, args: {}, 
+              opts: d.options.merge(name: d.name, version: d.version, parent: self)
+            ).run
+          end
+        end
+
+        def validate_download_url!
+          unless url_exists?(download_url)
+            raise InstallFailure, 
+                  "Package #{package_full_name} is NOT found from url: #{download_url}."
+          end
+        end
+
+        def install!
+          download_package
+          uncompress_package
+          assure_dirs(build_path)
+          within build_path do
+            with compose_build_env_variables do
+              build_package
+            end
+          end
+          cleanup_build!
+        end
+
+        def uninstall!
+          if current?
+            remove_binstubs!
+            remove_symlinks! 
+          end
+          rmdir(install_path)
+          cleanup_temp!
+          cleanup_logs!
+        end
+
+        def cleanup_temp!
+          Luban::Deployment::Package::DependencyTypes.each do |type|
+            required_packages[type].each do |d|
+              self.class.worker_class(:installer, package: d.name).new(
+                config: config, backend: backend, 
+                cmd: :cleanup_all, args: {}, 
+                opts: d.options.merge(name: d.name, version: d.version, parent: self)
+              ).run
+            end
+          end
+          cleanup_build!
+        end
+
+        def cleanup_build!
+          rmdir(build_path)
+        end
+
+        def cleanup_logs!
+          rmdir(install_log_path)
+        end
+
+        def update_binstubs!
+          remove_binstubs!
+          remove_symlinks!
+          create_symlinks!
+          create_binstubs!
+        end
+
+        def create_symlinks!
+          ln(install_path, current_path)
+        end
+
+        def create_binstubs!
+          return unless directory?(bin_path)
+          find_cmd = "find #{bin_path}/* -type f -print && find #{bin_path}/* -type l -print"
+          capture(find_cmd).split("\n").each do |bin|
+            ln(bin, app_bin_path.join(File.basename(bin)))
+          end
+        end
+
+        def remove_symlinks!
+          return unless symlink?(current_path)
+          execute "[ -h #{current_path} ] && rm -f #{current_path}; true"
+        end
+
+        def remove_binstubs!
+          return unless directory?(current_bin_path)
+          find_cmd = "find #{current_bin_path}/* -type f -print && find #{current_bin_path}/* -type l -print"
+          capture(find_cmd).split("\n").each do |bin|
+            bin_symlink = app_bin_path.join(File.basename(bin))
+            execute "[ -h #{bin_symlink} ] && rm -f #{bin_symlink}; true"
+          end
+        end
+
+        def bootstrap
+          assure_dirs(etc_path, tmp_path, app_bin_path, install_path, install_log_path)
+        end
+
+        def download_package
+          info "Downloading #{package_full_name} source package"
+          if file?(src_file_path)
+            info "#{package_full_name} is downloaded ALREADY"
+          else
+            download_package!
+          end
+        end
+
+        def download_package!
+          unless test("curl -L -o #{src_file_path} #{download_url} >> #{install_log_file_path} 2>&1")
+            rm(src_file_path)
+            abort_action('download')
+          end
+        end
+
+        def uncompress_package
+          info "Uncompressing #{package_full_name} source package"
+          uncompress_package!
+        end
+
+        def uncompress_package!
+          unless test("tar -xzf #{src_file_path} -C #{package_tmp_path} >> #{install_log_file_path} 2>&1")
+            abort_action('uncompress')
+          end
+        end
+
+        def build_package
+          configure_package
+          make_package
+          install_package
+        end
+
+        def configure_package
+          info "Configuring #{package_full_name}"
+          abort_action('configure') unless configure_package!
+        end
+
+        def configure_package!
+          test(configure_executable, 
+               "#{compose_build_options} >> #{install_log_file_path} 2>&1")
+        end
+
+        def make_package
+          info "Making #{package_full_name}"
+          abort_action('make') unless make_package!
+        end
+
+        def make_package!
+          test(:make, ">> #{install_log_file_path} 2>&1")
+        end
+
+        def install_package
+          info "Installing #{package_full_name}"
+          abort_action('install') unless install_package!
+        end
+
+        def install_package!
+          test(:make, "install >> #{install_log_file_path} 2>&1")
+        end
+
+        def abort_action(action)
+          cleanup_temp!
+          task.result.status = :failed
+          task.result.message = "Failed to #{action} package #{package_full_name}." +
+                                "Please check install log for details: #{install_log_file_path}" 
+          raise InstallFailure, task.result.message
+        end
+      end
+    end
+  end
+end

data/lib/luban/deployment/cli/package/installer/paths.rb

@@ -0,0 +1,81 @@
+module Luban
+  module Deployment
+    module Package
+      class Installer
+        DefaultSrcFileExtName = 'tar.gz'
+
+        def src_file_name
+          @src_file_name ||= "#{package_full_name}.#{src_file_extname}"
+        end
+
+        def src_file_extname
+          @src_file_extname ||= DefaultSrcFileExtName
+        end
+
+        def src_file_path
+          @src_file_path ||= tmp_path.join(src_file_name)
+        end
+
+        def source_repo
+          raise NotImplementedError, "#{self.class.name}#source_repo is an abstract method."
+        end
+
+        def download_from_source?
+          lubhub_repo.nil?
+        end
+
+        def download_from_lubhub?
+          !lubhub_repo.nil?
+        end
+
+        def download_repo
+          @download_repo ||= download_from_source? ? source_repo : lubhub_repo
+        end
+
+        def source_url_root
+          raise NotImplementedError, "#{self.class.name}#source_url_root is an abstract method."
+        end
+
+        def download_url_root
+          @download_url_root ||= download_from_source? ? source_url_root : package_name
+        end
+
+        def download_url
+          @download_url ||= File.join(download_repo, download_url_root, src_file_name)
+        end
+
+        def install_path
+          @install_path ||= package_path.join('versions', package_version)
+        end
+
+        def bin_path
+          @bin_path ||= install_path.join('bin')
+        end
+
+        def lib_path
+          @lib_path ||= install_path.join('lib')
+        end
+
+        def include_path
+          @include_path ||= install_path.join('include')
+        end
+
+        def build_path
+          @build_path ||= package_tmp_path.join(package_full_name)
+        end
+
+        def install_log_path
+          @install_log_path ||= package_path.join('log').join(package_full_name)
+        end
+
+        def install_log_file_path
+          @install_log_file_path ||= install_log_path.join(install_log_file_name)
+        end
+
+        def install_log_file_name
+          @install_log_file_name ||= "#{package_full_name}-install-#{Time.now.strftime("%Y%m%d-%H%M%S")}.log"
+        end
+      end
+    end
+  end
+end

data/lib/luban/deployment/cli/package/installer.rb

@@ -0,0 +1,3 @@
+require_relative 'installer/core'
+require_relative 'installer/paths'
+require_relative 'installer/install'

data/lib/luban/deployment/cli/package/service.rb

@@ -0,0 +1,17 @@
+module Luban
+  module Deployment
+    module Package
+      class Service < Binary
+        include Luban::Deployment::Command::Tasks::Deploy
+        include Luban::Deployment::Command::Tasks::Control
+
+        %i(deploy).each do |m|
+          define_task_method(m, worker: :deployer)
+        end
+
+        protected
+
+      end
+    end
+  end
+end

data/lib/luban/deployment/cli/package/worker.rb

@@ -0,0 +1,43 @@
+module Luban
+  module Deployment
+    module Package
+      class Worker < Luban::Deployment::Worker::Remote
+        class << self
+          def package_class(package)
+            Luban::Deployment::Package::Base.package_class(package)
+          end
+
+          def worker_class(worker, **opts)
+            Luban::Deployment::Package::Base.worker_class(worker, **opts)
+          end
+        end
+
+        def package_name; task.opts.name; end
+        def package_full_name; "#{package_name}-#{package_version}"; end
+
+        def package_version; task.opts.version; end
+        def package_major_version; task.opts.major_version; end
+        def package_patch_level; task.opts.patch_level; end
+
+        def child?; !task.opts.parent.nil?; end
+        def parent; task.opts.parent; end
+
+        def current_path
+          @current_path ||= app_path.join(package_name)
+        end
+
+        def current_bin_path
+          @current_bin_path ||= current_path.join('bin')
+        end
+
+        def package_path
+          @package_path ||= luban_install_path.join('pkg', package_name)
+        end
+
+        def package_tmp_path
+          @package_tmp_path ||= package_path.join('tmp')
+        end
+      end
+    end
+  end
+end

data/lib/luban/deployment/cli/package.rb

@@ -0,0 +1,6 @@
+require_relative 'package/dependency'
+require_relative 'package/dependency_set'
+require_relative 'package/binary'
+require_relative 'package/service'
+require_relative 'package/worker'
+require_relative 'package/installer'

data/lib/luban/deployment/cli/project.rb

@@ -0,0 +1,94 @@
+module Luban
+  module Deployment
+    class Project < Luban::Deployment::Command
+      using Luban::CLI::CoreRefinements
+      include Luban::Deployment::Parameters::Project
+      include Luban::Deployment::Command::Tasks::Install
+      include Luban::Deployment::Command::Tasks::Deploy
+      include Luban::Deployment::Command::Tasks::Control
+
+      attr_reader :apps
+
+      def display_name; @display_name ||= "#{stage} #{project.camelcase}"; end
+
+      def package_users_for(package_name, package_version, exclude: [], servers: [])
+        apps.values.inject([]) do |package_users, app|
+          if !exclude.include?(app.name) and
+              app.use_package?(package_name, package_version, servers: servers)
+            package_users << app.display_name
+          end
+          package_users
+        end
+      end
+
+      def password_for(user)
+        @passwords_mutex.synchronize do
+          if @passwords[user].nil?
+            @passwords[user] = ask(prompt: "Password for #{user}", echo: false)
+          end
+          @passwords[user]
+        end
+      end
+
+      %i(installable? deployable? controllable?).each do |method|
+        define_method(method) do
+          apps.values.any? { |app| app.send(__method__) }
+        end
+      end
+
+      %i(build destroy_project cleanup binstubs
+         show_current show_summary which whence
+        ).each do |action|
+        define_method(action) do |args:, opts:|
+          apps.each_value do |app|
+            app.send(__method__, args: args, opts: opts) if app.installable?
+          end
+        end
+      end
+
+      alias_method :destroy, :destroy_project
+
+      protected
+
+      def validate_parameters
+        super
+        validate_project_parameters
+      end
+
+      def set_default_parameters
+        super
+        set_default :stage, self.class.name.split('::').first.snakecase
+        set_default :project, self.class.name.split('::').last.snakecase
+        set_default_project_parameters
+        @passwords = {}
+        @passwords_mutex = Mutex.new
+      end
+
+      def load_libraries
+        applications.each do |app|
+          require "#{work_dir}/apps/#{app}/lib/application"
+        end
+      end
+
+      def application_base_class(app)
+        Object.const_get("#{project}:#{app}".camelcase)
+      end
+
+      def setup_cli
+        setup_applications
+        super
+      end
+
+      def setup_descriptions
+        desc "Manage apps in #{display_name}"
+      end
+
+      def setup_applications
+        @apps = {}
+        applications.map(&:to_sym).each do |app|
+          @apps[app] = command(app, base: application_base_class(app))
+        end
+      end
+    end
+  end
+end

data/lib/luban/deployment/cli.rb

@@ -0,0 +1,4 @@
+require_relative 'cli/command'
+require_relative 'cli/project'
+require_relative 'cli/application'
+require_relative 'cli/package'

data/lib/luban/deployment/configuration/core.rb

@@ -0,0 +1,67 @@
+module Luban
+  module Deployment
+    class Configuration
+      attr_reader :variables
+      attr_reader :servers
+
+      def initialize
+        @variables = {}
+        @servers = ServerSet.new
+      end
+
+      def set(key, value)
+        @variables[key] = value  
+      end
+
+      def set_default(key, value)
+        set(key, value) unless @variables.has_key?(key)
+      end
+
+      def delete(key)
+        @variables[key] = value
+      end
+
+      def fetch(key, default = nil, &blk)
+        value = if block_given?
+                  @variables.fetch(key, &blk)
+                else
+                  @variables.fetch(key, default)
+                end
+        while callable_without_parameters?(value) 
+          value = set(key, value.call)
+        end
+        return value
+      end
+
+      def keys
+        @variables.keys
+      end
+
+      def role(name, hosts, **properties)
+        if name == :all
+          raise ArgumentError, 'Reserved role name, :all, is NOT allowed to use.'
+        end
+        @servers.add_hosts_for_role(name, hosts, properties)
+      end
+
+      def server(name, **properties)
+        new_server = servers.add_host(name, properties)
+        if new_server
+          new_server.ssh_options = fetch(:ssh_options) || {}
+        end
+      end
+
+      def ask(key=nil, default:, prompt: nil, echo: true)
+        Question.new(default: default, prompt: prompt, echo: echo).call.tap do |answer|
+          set(key, answer) unless key.nil?
+        end
+      end
+
+      protected
+
+      def callable_without_parameters?(x)
+        x.respond_to?(:call) && (!x.respond_to?(:arity) || x.arity == 0)
+      end
+    end
+  end
+end

data/lib/luban/deployment/configuration/filter.rb

@@ -0,0 +1,54 @@
+module Luban
+  module Deployment
+    class Configuration
+      def roles(*names)
+        opts = names.last.is_a?(::Hash) ? names.pop : {}
+        filter_servers(servers.find_by_roles(filter_roles(names), opts))
+      end
+
+      def release_roles(*names)
+        if names.last.is_a?(Hash)
+          names.last.merge(:exclude => :no_release)
+        else
+          names << { :exclude => :no_release }
+        end
+        roles(*names)
+      end
+
+      def primary(role)
+        servers.find_primary(role)
+      end
+
+      protected
+
+      def filter_roles(_roles)
+        available_roles = (env_filter(:roles) | config_filter(:roles)).map(&:to_sym)
+        available_roles = servers.available_roles if available_roles.empty?
+        if _roles.include?(:all)
+          available_roles
+        else
+          _roles.select { |name| available_roles.include?(name) }
+        end
+      end
+
+      def filter_servers(_servers)
+        filter_hosts = env_filter(:hosts) | config_filter(:hosts)
+        if filter_hosts.empty?
+          _servers
+        else
+          _servers.select { |server| filter_hosts.include?(server.hostname) }
+        end
+      end
+
+      def env_filter(type)
+        type = type.to_s.upcase
+        ENV[type].nil? ? [] : ENV[type].split(',')
+      end
+
+      def config_filter(type)
+        filter = fetch(:filter) || fetch(:select)
+        filter.nil? ? [] : filter.fetch(type, [])
+      end
+    end
+  end
+end