luban 0.2.0

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

@@ -0,0 +1,38 @@
+module Luban
+  module Deployment
+    class Configuration
+      class Question
+        attr_reader :prompt, :default
+
+        def initialize(default:, prompt: nil, echo: true)
+          @default = default
+          @echo = echo
+          @prompt = "#{prompt.to_s}: " unless prompt.nil?
+        end
+
+        def echo?; @echo; end
+
+        def call
+          ask_question
+          get_response
+        end
+
+        protected
+
+        def ask_question
+          $stdout.print prompt
+        end
+
+        def get_response
+          response = if echo?
+                       $stdin.gets.chomp
+                     else
+                       require 'io/console'
+                       $stdin.noecho(&:gets).chomp.tap{ $stdout.print "\n" }
+                     end
+          response.empty? ? default : response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+require 'set'
+
+module Luban
+  module Deployment
+    class Configuration
+      class Server < SSHKit::Host
+        attr_reader :roles
+
+        def self.create(host, **properties)
+          server = host.is_a?(Server) ? host : Server.new(host)
+          server.add_properties(properties) unless properties.empty?
+          server.ssh_options ||= {}
+          server
+        end
+
+        def roles
+          self[:roles]
+        end
+
+        def add_roles(roles)
+          roles.each { |role| add_role(role) }
+        end 
+        alias_method :roles=, :add_roles
+
+        def add_role(role)
+          roles.add(role.to_sym)
+        end
+
+        def has_role?(role)
+          roles.include? role.to_sym
+        end
+
+        def properties
+          @properties ||= { :roles => Set.new }
+        end
+
+        def [](key)
+          properties[key] 
+        end
+        alias_method :fetch, :[]
+
+        def []=(key, value)
+          if respond_to?("#{key}=")
+            send("#{key}=", value)
+          else
+            pval = properties[key]
+            if pval.is_a? Hash and value.is_a? Hash
+              pval.merge!(value)
+            elsif pval.is_a? Set and value.is_a? Set
+              pval.merge(value)
+            elsif pval.is_a? Array and value.is_a? Array
+              pval.concat value
+            else
+              properties[key] = value
+            end
+          end 
+        end
+        alias_method :set, :[]=
+
+       def add_properties(_properties)
+          _properties.each { |k, v| self[k] = v }
+        end
+
+        def primary?
+          self[:primary]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+module Luban
+  module Deployment
+    class Configuration
+      class ServerSet
+        include Enumerable
+
+        def initialize
+          @servers = { :all => [] } 
+        end
+
+        def all
+          @servers[:all]
+        end
+
+        def available_roles
+          @servers.keys - [:all]
+        end
+
+        def has_server?(server)
+          all.find do |s|
+            s.user == server.user and
+            s.hostname == server.hostname and
+            s.port == server.port
+          end
+        end
+
+        def add_host(host, **properties)
+          new_server = Server.create(host, properties)
+          if server = has_server?(new_server)
+            server.user = new_server.user unless new_server.user.nil?
+            server.port = new_server.port unless new_server.port.nil?
+            server.add_properties(properties)
+            server
+          else
+            all << new_server
+            new_server.roles.each do |role| 
+              @servers[role] ||= []
+              @servers[role] << new_server
+            end
+            new_server
+          end
+        end
+
+        def add_hosts_for_role(role, hosts, **properties)
+          properties_deepcopy = Marshal.dump(properties.merge(:roles => Array(role)))
+          Array(hosts).each { |host| add_host(host, Marshal.load(properties_deepcopy)) }
+        end
+
+        def find_by_roles(roles, **opts)
+          roles.inject([]) do |result, role|
+            result.concat(find_by_role(role, opts))
+          end
+        end
+
+        def find_by_role(role, **opts)
+          if @servers.has_key?(role)
+            opts.inject(@servers[role]) do |_servers, (action, key)|
+              send(action, _servers, key)
+            end
+          else
+            []
+          end
+        end
+
+        def find_primary(role)
+          _servers = find_by_role(role)
+          _servers.find(&:primary?) || _servers.first
+        end
+
+        def each
+          all.each { |server| yield server }
+        end
+
+        protected
+
+        def exclude(_servers, key)
+          _servers.select { |server| !server[key] }
+        end
+
+        def filter(_servers, key)
+          _servers.select { |server| server[key] }
+        end
+      end
+    end
+  end
+end

data/lib/luban/deployment/configuration.rb

@@ -0,0 +1,5 @@
+require_relative 'configuration/core'
+require_relative 'configuration/filter'
+require_relative 'configuration/question'
+require_relative 'configuration/server'
+require_relative 'configuration/server_set'

data/lib/luban/deployment/error.rb

@@ -0,0 +1,5 @@
+module Luban
+  module Deployment
+    class Error < StandardError; end
+  end
+end

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

@@ -0,0 +1,159 @@
+module Luban
+  module Deployment
+    module Helpers
+      module Configuration
+        attr_accessor :config
+
+        def config
+          @config ||= Luban::Deployment::Configuration.new
+        end
+
+        def fetch(key, *args, &blk)
+          config.fetch(key, *args, &blk)
+        end
+
+        def set(key, *args, &blk)
+          config.set(key, *args, &blk)
+        end
+
+        def set_default(key, *args, &blk)
+          config.set_default(key, *args, &blk)
+        end
+
+        def ask(key=nil, default: nil, prompt: nil, echo: true)
+          config.ask(key, default: default, echo: echo, prompt: prompt)
+        end
+
+        def role(name, hosts, **properties)
+          config.role(name, hosts, properties)
+        end
+
+        def server(name, **properties)
+          config.server(name, properties)
+        end
+
+        def roles(*names)
+          config.roles(*names)
+        end
+
+        def release_roles(*names)
+          config.release_roles(*names)
+        end
+
+        def primary(role)
+          config.primary(role)
+        end
+
+        def load_configuration_file(config_file, optional: false)
+          if File.file?(config_file)
+            if error = syntax_error?(config_file)
+              abort "Aborted! Syntax errors in configuration file.\n#{error}"
+            else
+              instance_eval(File.read(config_file))
+            end
+          else
+            unless optional
+              abort "Aborted! Configuration file is NOT found: #{config_file}"
+            end
+          end
+        end
+
+        def syntax_error?(file)
+          _stderr = $stderr
+          $stderr = StringIO.new('', 'w')
+          # ONLY work for MRI Ruby
+          RubyVM::InstructionSequence.compile_file(file)
+          $stderr.string.chomp.empty? ? false : $stderr.string
+        ensure
+          $stderr = _stderr
+        end
+
+        def find_template_file(file_name)
+          path = find_template_file_by_config_finder(file_name) ||
+                 find_default_template_file(file_name)
+          raise RuntimeError, "Template file is NOT found: #{file_name}." if path.nil?
+          path
+        end
+
+        protected
+
+        def find_template_file_by_config_finder(file_name)
+          path = config_finder[:application].find_template_file(file_name) ||
+                 config_finder[:project].find_template_file(file_name)
+        end
+
+        def find_default_template_file(file_name)
+          path = File.expand_path(File.join(File.dirname(__FILE__), '..', 
+                                            'templates', file_name))
+          return path if File.file?(path)
+        end
+
+        class Finder
+          class Project < Finder
+            def base_path; base_path ||= target.work_dir; end
+          end
+
+          class Application < Finder
+            def base_path; base_path ||= target.apps_path.join(target.application); end
+          end
+
+          def self.project(target); Project.new(target); end
+          def self.application(target); Application.new(target); end
+
+          attr_reader :target
+          attr_reader :base_path
+          attr_reader :config_root
+          attr_reader :config_file
+          attr_reader :config_path
+          attr_reader :templates_path
+          attr_reader :stage_config_file
+          attr_reader :stage_config_path
+          attr_reader :stage_templates_path
+
+          def initialize(target)
+            @target = target
+            set_config_paths
+          end
+
+          def deployfile; @deployfile ||= 'deploy.rb';   end
+          def stagefile;  @stagefile  ||= "#{target.stage}.rb"; end
+
+          def load_configuration
+            load_general_configuration
+            load_stage_configuration
+          end
+
+          def load_general_configuration
+            target.load_configuration_file(config_file)
+          end
+
+          def load_stage_configuration
+            target.load_configuration_file(stage_config_file)
+            if File.directory?(stage_config_path)
+              Dir[stage_config_path.join("{packages}/**/*.rb")].each do |file|
+                target.load_configuration_file(file)
+              end
+            end
+          end
+
+          def find_template_file(file_name)
+            return file_path if File.file?(file_path = stage_templates_path.join(file_name))
+            return file_path if File.file?(file_path = templates_path.join(file_name))
+          end
+
+          protected
+
+          def set_config_paths
+            @config_root = base_path.join('config')
+            @config_file = @config_root.join(deployfile)
+            @config_path = @config_root.join(deployfile.sub('.rb', ''))
+            @templates_path = @config_root.join('templates')
+            @stage_config_file = @config_path.join(stagefile)
+            @stage_config_path = @config_path.join(target.stage)
+            @stage_templates_path = @stage_config_path.join('templates')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/luban/deployment/helpers/utils.rb

@@ -0,0 +1,180 @@
+require "digest/md5"
+
+module Luban
+  module Deployment
+    module Helpers
+      module Utils
+        LogLevels = %i(fatal error warn info debug trace)
+
+        attr_reader :backend
+
+        def check_pass?(type, *args)
+          send("#{type}?", *args)
+        end
+
+        def directory?(path)
+          test "[ -d #{path} ]"
+        end
+
+        def file?(path)
+          test "[ -f #{path} ]"
+        end
+
+        def symlink?(path)
+          test "[ -L #{path} ]"
+        end
+
+        def match?(cmd, expect)
+          expect = Regexp.new(Regexp.escape(expect.to_s)) unless expect.is_a?(Regexp)
+          output = capture(cmd)
+          output =~ expect
+        end
+
+        def assure(type, *args)
+          unless check_pass?(type, *args)
+            if block_given?
+              yield
+            else
+              abort "Aborted! #{type} dependency with #{args.inspect} are not met and no block is given to resolve it."
+            end
+          end
+        end
+
+        def assure_dirs(*dirs)
+          dirs.each { |dir| assure(:directory, dir) { mkdir(dir) } }
+        end
+
+        def assure_symlink(source_path, target_path)
+          unless symlink?(target_path) and readlink(target_path) == source_path.to_s
+            ln(source_path, target_path)
+          end
+        end
+
+        def mkdir(*opts, path)
+          execute(:mkdir, '-p', *opts, path)
+        end
+
+        def rm(*opts, path)
+          execute(:rm, '-fr', *opts, path)
+        end
+        alias_method :rmdir, :rm
+
+        def chmod(*opts, path)
+          execute(:chmod, '-R', *opts, path)
+        end
+
+        def ln(*opts, source_path, target_path)
+          execute(:ln, '-nfs', *opts, source_path, target_path)
+        end
+
+        def mv(*opts, source_path, target_path)
+          execute(:mv, *opts, source_path, target_path)
+        end
+
+        def cp(*opts, source_path, target_path)
+          execute(*opts, source_path, target_path)
+        end
+
+        def readlink(source_file)
+          capture("$(type -p readlink greadlink|head -1) #{source_file}") 
+        end
+
+        def md5_for_file(file)
+          capture(:cat, "#{file} 2>/dev/null | openssl md5")
+        end
+
+        def sudo(*args)
+          execute(:sudo, *args)
+        end
+
+        def os_name
+          @os_name ||= capture("uname -s")
+        end
+
+        def os_release
+          @os_release ||= capture("uname -r")
+        end
+
+        def hardware_name
+          @hardware_name ||= capture("uname -m")
+        end
+
+        def user_home
+          @user_home ||= capture("eval echo ~")
+        end
+
+        def url_exists?(download_url)
+          # Sent HEAD request to avoid downloading the file contents
+          test("curl -s -L -I -o /dev/null -f #{download_url}")
+
+          # Other effective ways to check url existence with curl
+
+          # In case HEAD request is refused, 
+          # only the first byte of the file is requested
+          # test("curl -s -L -o /dev/null -f -r 0-0 #{download_url}")
+
+          # Alternatively, http code (200) can be validated
+          # capture("curl -s -L -I -o /dev/null -w '%{http_code}' #{download_url}") == '200'
+        end
+
+        def upload_by_template(file_to_upload:, template_file:, auto_revision: false, **opts)
+          template = File.read(template_file)
+
+          if auto_revision and file?(file_to_upload)
+            revision = Digest::MD5.hexdigest(template)
+            return if revision_match?(file_to_upload, revision)
+          end
+
+          require 'erb'
+          context = opts[:binding] || binding
+          upload!(StringIO.new(ERB.new(template, nil, '<>').result(context)), file_to_upload)
+          yield file_to_upload if block_given?
+        end
+
+        def revision_match?(file_to_upload, revision)
+          match?("grep \"Revision: \" #{file_to_upload}", revision)
+        end
+
+        [:test, :make, :within, :with, :as, :execute, 
+         :upload!, :download!].each do |cmd|
+          define_method(cmd) do |*args, &blk|
+            backend.send(__method__, *args, &blk)
+          end
+        end
+
+        def capture(*args, &blk)
+          backend.capture(*args, &blk).chomp
+        end
+
+        def md5_matched?(file_path, md5)
+          file?(file_path) and md5 == md5_for_file(file_path)
+        end
+
+        #def execute(*args, &blk)
+        #  if args.last.is_a?(::Hash)
+        #    args.last.merge(verbosity: SSHKit::Logger::DEBUG)
+        #  else
+        #    args.push(verbosity: SSHKit::Logger::DEBUG)
+        #  end
+        #  backend.execute(*args, &blk)
+        #end
+
+        LogLevels.each do |cmd|
+          define_method(cmd) { |msg| backend.send(__method__, "[#{hostname}] #{msg}") }
+        end
+
+        def host
+          @host ||= backend.host
+        end
+
+        def hostname
+          @hostname ||= host.hostname
+        end
+
+        def method_missing(sym, *args, &blk)
+          backend.respond_to?(sym) ? backend.send(sym, *args, &blk) : super
+        end
+      end
+    end
+  end
+end

data/lib/luban/deployment/helpers.rb

@@ -0,0 +1,2 @@
+require_relative 'helpers/configuration'
+require_relative 'helpers/utils'

data/lib/luban/deployment/packages/bundler.rb

@@ -0,0 +1,81 @@
+module Luban
+  module Deployment
+    module Packages
+      class Bundler < Luban::Deployment::Package::Binary
+        protected
+
+        def setup_install_tasks
+          super
+          commands[:install].switch :install_doc, "Install Bundler document"
+        end
+
+        class Installer < Luban::Deployment::Package::Installer
+          def install_doc?
+            task.opts.install_doc
+          end
+
+          def package_version
+            parent.task.opts.bundler || super
+          end
+
+          def package_path
+            parent.package_path
+          end
+
+          def install_path
+            parent.install_path
+          end
+
+          def bundler_executable
+            @bundler_executable ||= bin_path.join('bundle')
+          end
+
+          def gem_executable
+            parent.gem_executable
+          end
+
+          def src_file_extname
+            @src_file_extname ||= 'gem'
+          end
+
+          def source_repo
+            #@source_repo ||= "http://production.cf.rubygems.org"
+            @source_repo ||= "https://rubygems.org"
+          end
+
+          def source_url_root
+            @source_url_root ||= "downloads"
+          end
+
+          def installed?
+            return false unless file?(bundler_executable)
+            match?("#{bundler_executable} -v", package_version)
+          end
+
+          protected
+
+          def validate
+            if parent.nil?
+              abort "Aborted! Parent package for Bundler MUST be provided."
+            end
+            unless parent.is_a?(Ruby::Installer)
+              abort "Aborted! Parent package for Bundler MUST be an instance of #{Ruby::Installer.name}"
+            end
+          end
+
+          def uncompress_package; end
+          def configure_package; end
+          def make_package; end
+          def update_binstubs!; end
+
+          def install_package!
+            install_opts = ['--local']
+            install_opts << "--no-document" unless install_doc?
+            test("#{gem_executable} uninstall bundler -a -x -I >> #{install_log_file_path} 2>&1") and
+            test("#{gem_executable} install #{install_opts.join(' ')} #{src_file_path} >> #{install_log_file_path} 2>&1")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/luban/deployment/packages/git.rb

@@ -0,0 +1,37 @@
+module Luban
+  module Deployment
+    module Packages
+      class Git < Luban::Deployment::Package::Binary
+        apply_to :all do
+          before_install do
+            depend_on 'openssl', version: '1.0.2e'
+          end
+        end
+
+        class Installer < Luban::Deployment::Package::Installer
+          def git_executable
+            @git_executable ||= bin_path.join('git')
+          end
+
+          def source_repo
+            @source_repo ||= "https://www.kernel.org"
+          end
+
+          def source_url_root
+            @source_url_root ||= "pub/software/scm/git"
+          end
+
+          def installed?
+            return false unless file?(git_executable)
+            pattern = "version #{package_major_version}"
+            match?("#{git_executable} --version", pattern)
+          end
+
+          def with_openssl_dir(dir)
+            @configure_opts << "--with-openssl=#{dir}"
+          end
+        end
+      end
+    end
+  end
+end