luban 0.2.0

data/lib/luban/deployment/cli/application/repository.rb

@@ -0,0 +1,175 @@
+module Luban
+  module Deployment
+    class Application
+      class Repository < Luban::Deployment::Worker::Local
+        using Luban::CLI::CoreRefinements
+
+        DefaultRevisionSize = 12
+
+        attr_reader :name
+        attr_reader :from
+        attr_reader :scm
+        attr_reader :revision
+        attr_reader :rev_size
+
+        def scm_module
+          require_relative "scm/#{scm}"
+          @scm_module ||= SCM.const_get(scm.camelcase)
+        end
+
+        def workspace_path
+          @workspace_path ||= app_path.join('.luban')
+        end
+
+        def clone_path
+          @clone_path ||= workspace_path.join('repositories').join(name)
+        end
+
+        def releases_path
+          @releases_path ||= workspace_path.join('releases').join(name)
+        end
+
+        def release_package_path
+          @release_package_path ||= releases_path.join(release_package_file_name)
+        end
+
+        def release_package_file_name
+          @release_package_file_name ||= "#{release_package_name}.#{release_package_extname}"
+        end
+
+        def release_package_name
+          @release_package_name ||= "#{release_prefix}-#{release_tag}"
+        end
+
+        def release_package_extname
+          @release_package_extname ||= 'tgz'
+        end
+
+        def release_prefix
+          @release_prefix ||= "#{stage}-#{project}-#{application}-#{name}"
+        end
+
+        def release_tag
+          @release_tag ||= "#{stage}-#{revision}"
+        end
+
+        def bundle_without
+          @bundle_without ||= %w(development test)
+        end
+
+        # Description on abstract methods:
+        #   available?: check if the remote repository is available
+        #   cloned?: check if the remote repository is cloned locally
+        #   fetch_revision: retrieve the signature/checksum of the commit that will be deployed
+        #   clone: clone a new copy of the remote repository
+        #   update: update the clone of the remote repository
+        #   release: copy the contents of cloned repository onto the release path
+        [:available?, :cloned?, :fetch_revision, :clone, :update, :release].each do |method|
+          define_method(method) do
+            raise NotImplementedError, "\#{self.class.name}##{__method__} is an abstract method."
+          end
+        end
+
+        def build
+          assure_dirs(clone_path, releases_path)
+          if cloned? and !force?
+            update_revision
+            update_result "Skipped! Local #{name} repository has been built ALREADY.", status: :skipped
+          else
+            if available?
+              if build!
+                update_revision
+                update_result "Successfully built local #{name} repository."
+              else
+                update_result "FAILED to build local #{name} repository!", status: :failed, level: :error
+              end
+            else
+              update_result "Aborted! Remote #{name} repository is NOT available.", status: :failed, level: :error
+            end
+          end
+        end
+
+        def package
+          if cloned?
+            if package!
+              cleanup_releases
+              update_result "Successfully package local #{name} repository to #{release_package_path}.", 
+                            release: { name: name, tag: release_tag,
+                                       path: release_package_path, 
+                                       md5: md5_for_file(release_package_path),
+                                       bundled_gems: bundle_gems }
+            else
+              update_result "FAILED to package local #{name} repository!", status: :failed, level: :error
+            end
+          else
+            update_result "Aborted! Local #{name} package is NOT built yet!", status: :failed, level: :error
+          end
+        end
+
+        protected
+
+        def init
+          @rev_size = DefaultRevisionSize
+          task.opts.repository.each_pair { |name, value| instance_variable_set("@#{name}", value) }
+          load_scm
+        end
+
+        def load_scm
+          singleton_class.send(:prepend, scm_module)
+        end
+
+        def build!
+          rmdir(clone_path)
+          clone
+        end
+
+        def package!
+          if update
+            update_revision
+            release
+          end
+        end
+
+        def update_revision
+          @revision = fetch_revision
+        end
+
+        def cleanup_releases
+          files = capture(:ls, '-xt', releases_path).split
+          if files.count > keep_releases
+            within(releases_path) do
+              files.last(files.count - keep_releases).each { |f| rm(f) }
+            end
+          end
+        end
+
+        def bundle_gems
+          gemfile_path = Pathname.new(release_tag).join('Gemfile')
+          gems_cache = Pathname.new('vendor').join('cache')
+          bundle_path = Pathname.new('vendor').join('bundle')
+          bundled_gems = {}
+          gems = bundled_gems[:gems] = {}
+          if test(:tar, "-tzf #{release_package_path} #{gemfile_path} > /dev/null 2>&1")
+            within(workspace_path) do
+              execute(:tar, "--strip-components=1 -xzf #{release_package_path} #{gemfile_path}")
+              unless test(:bundle, :check, "--path #{bundle_path}")
+                execute(:bundle, :install, "--path #{bundle_path} --without #{bundle_without.join(' ')} --quiet")
+                info "Package gems bundled in Gemfile"
+                execute(:bundle, :package, "--all --quiet")
+              end
+              gem_files = capture(:ls, '-xt', gems_cache).split
+              gem_files.each do |gem_file|
+                gems[gem_file] = md5_for_file(gems_cache.join(gem_file))
+              end
+            end
+            bundled_gems[:gems_cache] = workspace_path.join(gems_cache)
+            workspace_path.join('Gemfile.lock').tap do |p|
+              bundled_gems[:locked_gemfile] = { path: p, md5: md5_for_file(p) }
+            end
+          end
+          bundled_gems
+        end
+      end
+    end
+  end
+end

data/lib/luban/deployment/cli/application/scm/git.rb

@@ -0,0 +1,49 @@
+module Luban
+  module Deployment
+    class Application
+      class Repository
+        module SCM
+          module Git
+            attr_reader :tag
+            attr_reader :branch
+
+            def git_cmd; :git; end
+
+            def ref
+              tag || branch || @ref
+            end
+
+            def available?
+              test(git_cmd, 'ls-remote --heads', from)
+            end
+
+            def cloned?
+              file?(clone_path.join("HEAD"))
+            end
+
+            def fetch_revision
+              within(clone_path) { capture(git_cmd, "rev-parse --short=#{rev_size} #{ref}") }
+              #within(clone_path) { capture(git_cmd, "rev-list --max-count=1 --abbrev-commit --abbrev=rev_size #{ref}") }
+            end
+
+            def clone
+              test(git_cmd, :clone, '--mirror', from, clone_path)
+            end
+
+            def update
+              within(clone_path) { test(git_cmd, :remote, :update, "--prune") }
+            end
+
+            def release
+              within(clone_path) { test(git_cmd, :archive, ref, "--prefix=#{release_tag}/ -o #{release_package_path}") }
+            end
+
+            def release_tag
+              @release_tag ||= "#{ref}-#{revision}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/luban/deployment/cli/application/scm/rsync.rb

@@ -0,0 +1,47 @@
+module Luban
+  module Deployment
+    class Application
+      class Repository
+        module SCM
+          module Rsync
+            def init
+              super
+              @from = Pathname.new(@from) unless from.is_a?(Pathname)
+            end
+
+            def rsync_cmd; :rsync; end
+
+            def available?; directory?(from); end
+
+            def cloned?
+              directory?(clone_path) and 
+              test("[ \"$(ls -A #{clone_path})\" ]") # Not empty
+            end
+
+            def fetch_revision
+              # Use MD5 as the revision
+              capture(:tar, "-cf - #{dir} 2>/dev/null | openssl md5")[0, rev_size]
+            end
+
+            def clone
+              test(rsync_cmd, "-acz", "#{from}/", clone_path)
+            end
+
+            def update
+              test(rsync_cmd, "-acz", "--delete", "#{from}/", clone_path)
+            end
+
+            def release
+              within(releases_path) do
+                assure_dirs(release_tag)
+                execute(:tar, "-C #{clone_path} -cf - . | tar -C #{release_tag} -xf -")
+                execute(:tar, "-czf", release_package_path, release_tag)
+                rm(release_tag)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+require_relative 'application/base'
+require_relative 'application/authenticator'
+require_relative 'application/builder'
+require_relative 'application/repository'
+require_relative 'application/publisher'

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

@@ -0,0 +1,360 @@
+module Luban
+  module Deployment
+    class Command < Luban::CLI::Command
+      module Tasks
+        module Install
+          %i(build destroy cleanup binstubs
+             show_current show_summary which whence).each do |action|
+            define_method(action) do |args:, opts:|
+              raise NotImplementedError, "#{self.class.name}##{__method__} is an abstract method."
+            end
+          end
+
+          def installable?; true; end
+
+          protected
+
+          def setup_install_tasks
+            _self = self
+            task :build do
+              desc "Build #{_self.display_name} environment"
+              switch :force, "Force to build", short: :f
+              action! :build
+            end
+
+            task :destroy do
+              desc "Destroy #{_self.display_name} environment"
+              switch :force, "Force to destroy", short: :f, required: true
+              action! :destroy
+            end
+
+            task :cleanup do
+              desc "Clean up temporary files during installation"
+              action! :cleanup
+            end
+
+            task :binstubs do
+              desc "Update binstubs for required packages"
+              switch :force, "Force to update binstubs", short: :f
+              action! :binstubs
+            end
+
+            task :version do
+              desc "Show current version for required packages"
+              action! :show_current
+            end
+
+            task :versions do
+              desc "Show package installation summary"
+              action! :show_summary
+            end
+
+            task :which do
+              desc "Show the real path for the given executable"
+              argument :executable, "Executable to which", short: :e, required: true
+              action! :which
+            end
+
+            task :whence do
+              desc "List packages with the given executable"
+              argument :executable, "Executable to whence", short: :e, required: true
+              action! :whence
+            end
+          end
+        end
+
+        module Deploy
+          %i(deploy rollback).each do |action| 
+            define_method(action) do |args:, opts:|
+              raise NotImplementedError, "#{self.class.name}##{__method__} is an abstract method."
+            end
+          end
+
+          def deployable?; true; end
+
+          protected
+
+          def setup_deploy_tasks
+            task :deploy do
+              desc "Run deployment"
+              action! :deploy
+            end
+          end
+        end
+
+        module Control
+          %i(start_process stop_process restart_process
+             show_process_status test_process 
+             monitor_process unmonitor_process).each do |action|
+            define_method(action) do |args:, opts:|
+              raise NotImplementedError, "#{self.class.name}##{__method__} is an abstract method."
+            end
+          end
+
+          def controllable?; true; end
+
+          protected
+
+          def setup_control_tasks
+            task :start do
+              desc "Start process"
+              action! :start_process
+            end
+
+            task :stop do
+              desc "Stop process"
+              action! :stop_process
+            end
+
+            task :restart do
+              desc "Restart process"
+              action! :restart_process
+            end
+
+            task :status do
+              desc "Show process status"
+              action! :show_process_status
+            end
+
+            task :test do
+              desc "Test process"
+              action! :test_process
+            end
+
+            task :monitor do
+              desc "Turn on process monitor"
+              action! :monitor_process
+            end
+
+            task :unmonitor do
+              desc "Turn off process monitor"
+              action! :unmonitor_process
+            end
+          end
+        end
+      end
+
+      using Luban::CLI::CoreRefinements
+      include Luban::Deployment::Helpers::Configuration
+      include Luban::Deployment::Parameters::General
+
+      def display_name; @display_name ||= name.camelcase; end
+
+      def installable?;  false; end
+      def deployable?;   false; end
+      def controllable?; false; end
+
+      def task(cmd, **opts, &blk)
+        command(cmd, **opts, &blk).tap do |c|
+        add_common_task_options(c)
+          if !c.summary.nil? and c.description.empty?
+            c.long_desc "#{c.summary} in #{self.class.name}"
+          end
+        end
+      end
+
+      alias_method :undef_task, :undef_command
+
+      class << self
+        def default_worker_class
+          Luban::Deployment::Worker::Base
+        end
+
+        def worker_class(worker)
+          class_name = worker.camelcase
+          if const_defined?(class_name)
+            const_get(class_name)
+          else
+            abort "Aborted! #{name}::#{class_name} is NOT defined."
+          end
+        end
+
+        def define_task_method(method, task: method, worker:, locally: false, &blk)
+          define_method(method) do |args:, opts:|
+            run_task(cmd: task, args: args, opts: opts, locally: locally,
+                     worker_class: self.class.worker_class(worker), &blk)
+          end
+        end
+      end
+
+      def run_task(cmd: nil, args:, opts:, locally: false,
+                   worker_class: self.class.default_worker_class, &blk)
+        backtrace = opts.delete(:backtrace)
+        task_args = compose_task_arguments(args)
+        task_opts = compose_task_options(opts)
+        run_opts = extract_run_options(task_opts)
+        run_opts[:hosts] = :local if locally
+        task_msg = { cmd: cmd, config: config, local: locally,
+                     args: task_args, opts: task_opts}
+        result = []
+        mutex = Mutex.new
+        run(**run_opts) do |backend|
+          begin 
+            r = worker_class.new(task_msg.merge(backend: backend), &blk).run
+          rescue StandardError => e
+            r = {
+              status: :failed,
+              message: backtrace ? "#{e.message}\n#{e.backtrace.join("\n")}" : e.message,
+              error: e
+            }
+          end
+          mutex.synchronize { result << r }
+        end
+        print_task_result result
+        locally ? result.first[:__return__] : result
+      end
+
+      protected
+
+      def on_configure
+        super
+        set_parameters
+        set_default_parameters
+        load_configuration
+        validate_parameters
+        load_libraries
+        setup_cli
+      end
+
+      def set_parameters
+        copy_parameters_from_parent(
+          :luban_roles, :luban_root_path,
+          :stages, :production_stages, :applications,
+          :work_dir, :apps_path, :user
+        )
+      end
+
+      def copy_parameters_from_parent(*parameters)
+        parameters.each do |p| 
+          if parent.respond_to?(p)
+            send(p, parent.send(p))
+          else
+            abort "Aborted! #{self.class.name} failed to copy parameter #{p.inspect} from #{parent.class.name}."
+          end
+        end
+      end
+
+      def set_default_parameters
+        set_default_general_parameters
+      end
+
+      def load_configuration; end
+
+      def validate_parameters
+        validate_general_parameters
+      end
+
+      def load_libraries; end
+
+      def setup_cli
+        setup_descriptions
+        setup_tasks
+      end
+
+      def setup_descriptions; end
+
+      def setup_tasks
+        setup_install_tasks if installable?
+        setup_deploy_tasks if deployable?
+        setup_control_tasks if controllable?
+      end
+
+      %i(install deploy control).each do |operation|
+        define_method("setup_#{operation}_tasks") do
+          raise NotImplementedError, "#{self.class.name}##{__method__} is an abstract method."
+        end
+      end
+
+      def add_common_task_options(task)
+        task.switch :dry_run, "Run as a simulation", short: :d
+        task.switch :once, "Run ONLY once", short: :o
+        task.option :roles, "Run with given roles", 
+                    type: :symbol, multiple: true, default: luban_roles
+        task.option :hosts, "Run with given hosts", multiple: true, default: []
+        task.option :in, "Run in parallel, sequence or group", short: :i, 
+                    type: :symbol, within: [:parallel, :sequence, :groups], default: :parallel
+        task.option :wait, "Wait interval for every run in sequence or groups", short: :w,
+                    type: :integer, assure: ->(v){ v > 0 }, default: 2
+        task.option :limit, "Number of hosts per group", short: :n,
+                    type: :integer, assure: ->(v){ v > 0 }, default: 2
+        task.option :format, "Set output format", short: :F,
+                    type: :symbol, within: %i(pretty dot simpletext blackhole airbrussh),
+                    default: :blackhole
+        task.option :verbosity, "Set verbosity level", short: :V,
+                    type: :symbol, within: Luban::Deployment::Helpers::Utils::LogLevels,
+                    default: :info
+        task.switch :backtrace, "Enable backtrace for exceptions", short: :B
+      end
+
+      def extract_run_options(task_opts)
+        %i(once roles hosts in wait limit
+           dry_run format verbosity).inject({}) do |opts, n| 
+          opts[n] = task_opts.delete(n) if task_opts.has_key?(n)
+          opts
+        end
+      end
+
+      def compose_task_arguments(args); args.clone; end
+      def compose_task_options(opts); opts.clone; end
+
+      def run(roles: luban_roles, hosts: nil, once: false,
+              dry_run: false, format: log_format, verbosity: log_level, **opts)
+        configure_backend(dry_run: dry_run, format: format, verbosity: verbosity)
+        hosts = Array(hosts)
+        servers = select_servers(roles, hosts)
+        servers = servers.first if once and !servers.empty?
+        on(servers, **opts) { |backend| yield backend }
+      end
+
+      def select_servers(roles, hosts)
+        hosts.empty? ? release_roles(*roles) : hosts
+      end
+
+      def on(hosts, **opts, &blk)
+        SSHKit::Coordinator.new(hosts).each(opts) { blk.call(self) }
+      end
+
+      def print_task_result(result)
+        result.each do |entry|
+          next if entry[:message].to_s.empty?
+          puts "  [#{entry[:hostname]}] #{entry[:message]}"
+        end
+      end
+
+      def backend_configured?; @@backend_configured ||= false; end
+
+      def configure_backend(dry_run:, format:, verbosity:)
+        return if backend_configured?
+        enable_dry_run if dry_run
+
+        SSHKit.configure do |sshkit|
+          sshkit.format           = format
+          sshkit.output_verbosity = verbosity
+          sshkit.default_env      = default_env
+          sshkit.backend          = sshkit_backend
+          sshkit.backend.configure do |backend|
+            backend.pty                = pty
+            backend.connection_timeout = connection_timeout
+            backend.ssh_options        = 
+              backend.ssh_options.merge(user: user).merge!(ssh_options)
+          end
+        end
+
+        configure_airbrussh if format == :airbrussh
+        @@backend_configured = true
+      end
+
+      def configure_airbrussh
+        require 'airbrussh'
+        Airbrussh.configure do |config|
+          config.command_output = [:stdout, :stderr]
+        end
+        SSHKit.config.output = Airbrussh::Formatter.new($stdout)
+      end
+
+      def enable_dry_run
+        sshkit_backend SSHKit::Backend::Printer
+      end
+    end
+  end
+end