luban 0.2.0

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

@@ -0,0 +1,241 @@
+module Luban
+  module Deployment
+    module Package
+      class Binary < Luban::Deployment::Command
+        using Luban::CLI::CoreRefinements
+
+        class << self
+          def inherited(subclass)
+            super
+            # Ensure package dependencies from base class
+            # got inherited to its subclasses
+
+            subclass.instance_variable_set(
+              '@dependencies',
+              Marshal.load(Marshal.dump(dependencies))
+            )
+          end
+
+          def dependencies
+            @dependencies ||= DependencySet.new
+          end
+
+          def apply_to(version, &blk)
+            dependencies.apply_to(version, &blk)
+          end
+
+          def required_packages_for(version)
+            dependencies.dependencies_for(version)
+          end
+
+          def package_class(package)
+            require_path = package_require_path(package)
+            require require_path
+            package_base_class(require_path)
+          rescue LoadError => e
+            abort "Aborted! Failed to load package #{require_path}: #{e.message}"
+          end
+
+          def worker_class(worker, package: self)
+            if package.is_a?(Class)
+              if package == self
+                super(worker)
+              else
+                package.worker_class(worker)
+              end
+            else
+              package_class(package).worker_class(worker)
+            end
+          end
+
+          protected
+
+          def package_require_path(package_name)
+            package_require_root.join(package_name.to_s.gsub(':', '/'))
+          end
+
+          def package_require_root
+            @default_package_root ||= Pathname.new("luban/deployment/packages")
+          end
+
+          def package_base_class(path)
+            Object.const_get(path.to_s.camelcase, false)
+          end
+        end
+
+        include Luban::Deployment::Parameters::Project
+        include Luban::Deployment::Parameters::Application
+        include Luban::Deployment::Command::Tasks::Install
+
+        attr_reader :current_version
+
+        def package_options; @package_options ||= {}; end
+
+        def update_package_options(version, **opts)
+          unless package_options.has_key?(version)
+            package_options[version] = 
+              { name: name.to_s }.merge!(decompose_version(version))
+          end
+          @current_version = version if opts[:current]
+          package_options[version].merge!(opts)
+        end
+
+        def has_version?(version)
+          package_options.has_key?(version)
+        end
+
+        def decompose_version(version)
+          { major_version: version, patch_level: '' }
+        end
+
+        def versions; package_options.keys; end
+
+        %i(install uninstall cleanup_all update_binstubs
+           get_summary which_current whence_origin).each do |m| 
+          define_task_method(m, worker: :installer)
+        end
+
+        def install_all(args:, opts:)
+          versions.each do |v| 
+            install(args: args, opts: opts.merge(version: v))
+          end
+        end
+
+        def uninstall_all(args:, opts:)
+          versions.each do |v|
+            uninstall(args: args, opts: opts.merge(version: v))
+          end
+        end
+
+        alias_method :uninstall!, :uninstall
+        def uninstall(args:, opts:)
+          servers = select_servers(opts[:roles], opts[:hosts])
+          apps = parent.other_package_users_for(name, opts[:version], servers: servers)
+          if apps.empty? or opts[:force]
+            uninstall!(args: args, opts: opts)
+          else
+            puts "Skipped. #{name}-#{opts[:version]} is being referenced by #{apps.join(', ')}. " +
+                 "use -f to force uninstalling if necessary."
+          end
+        end
+
+        def cleanup(args:, opts:)
+          versions.each do |v|
+            cleanup_all(args: args, opts: opts.merge(version: v))
+          end
+        end
+
+        def binstubs(args:, opts:)
+          if current_version
+            update_binstubs(args: args, opts: opts.merge(version: current_version))
+          else
+            versions.each do |v|
+              update_binstubs(args: args, opts: opts.merge(version: v))
+            end
+          end
+        end
+
+        def show_current(args:, opts:)
+          if current_version
+            print_summary(get_summary(args: args, opts: opts.merge(version: current_version)))
+          else
+            puts "    Warning! No current version of #{display_name} is specified."
+          end
+        end
+
+        def show_summary(args:, opts:)
+          versions.each do |v|
+            print_summary(get_summary(args: args, opts: opts.merge(version: v)))
+          end
+        end
+
+        def which(args:, opts:)
+          if current_version
+            print_summary(which_current(args: args, opts: opts.merge(version: current_version)))
+          else
+            puts "    Warning! No current version of #{display_name} is specified."
+          end
+        end
+
+        def whence(args:, opts:)
+          versions.each do |v|
+            print_summary(whence_origin(args: args, opts: opts.merge(version: v)))
+          end
+        end
+
+        protected
+
+        def set_parameters
+          self.config = parent.config
+        end
+
+        def setup_tasks
+          super
+          setup_install_tasks
+        end
+
+        def compose_task_options(opts)
+          opts = super
+          version = opts[:version]
+          unless version.nil?
+            # Merge package options into task options without nil ones
+            opts = package_options[version].merge(opts.reject { |_, v| v.nil? })
+          end
+          opts
+        end
+
+        def setup_descriptions
+          desc "Manage package #{display_name}"
+          long_desc "Manage the deployment of package #{display_name} in #{parent.class.name}"
+        end
+
+        def setup_install_tasks
+          super
+
+          undef_task :build
+          undef_task :destroy
+
+          _package = self
+          task :install do
+            desc "Install a given version"
+            option :version, "Version to install", short: :v, required: true,
+                   assure: ->(v){ _package.versions.include?(v) }
+            switch :force, "Force to install", short: :f
+            action! :install
+          end
+
+          task :install_all do
+            desc "Install all versions"
+            switch :force, "Force to install", short: :f
+            action! :install_all
+          end
+
+          task :uninstall do
+            desc "Uninstall a given version"
+            option :version, "Version to uninstall", short: :v, required: true,
+                    assure: ->(v){ _package.versions.include?(v) }
+            switch :force, "Force to uninstall", short: :f
+            action! :uninstall
+          end
+
+          task :uninstall_all do
+            desc "Uninstall all versions"
+            switch :force, "Force to uninstall", short: :f, required: true
+            action! :uninstall_all
+          end
+        end
+
+        def print_summary(result)
+          result.each do |entry|
+            s = entry[:summary]
+            puts "  [#{entry[:hostname]}] #{s[:status]} #{s[:name]} #{s[:installed]}"
+            puts "  [#{entry[:hostname]}]      #{s[:executable]}" unless s[:executable].nil?
+            puts "  [#{entry[:hostname]}]    #{s[:alert]}" unless s[:alert].nil?
+          end
+        end
+      end
+
+      Base = Binary
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module Luban
+  module Deployment
+    module Package
+      DependencyTypes = %i(before_install after_install)
+
+      class Dependency
+        attr_reader :apply_to
+        attr_reader :type
+        attr_reader :name
+        attr_reader :version
+        attr_reader :options
+
+        def initialize(apply_to, type, name, version, **opts)
+          @apply_to = apply_to
+          @type = type
+          @name = name
+          @version = version
+          @options = opts
+          validate
+        end
+
+        def applicable_to?(version)
+          if @apply_to == :all
+            true
+          else
+            Gem::Requirement.new(@apply_to).satisfied_by?(Gem::Version.new(version))
+          end
+        end
+
+        protected
+
+        def validate
+          if @apply_to.nil?
+            raise ArgumentError, 'The version requirement that the dependency applies to is NOT provided.'
+          end
+          unless DependencyTypes.include?(@type)
+            raise ArgumentError, "Invalid dependency type: #{type.inspect}"
+          end
+          if @name.nil?
+            raise ArgumentError, 'Dependency name is NOT provided.'
+          end
+          if @version.nil?
+            raise ArgumentError, 'Dependency version is NOT provided.'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+module Luban
+  module Deployment
+    module Package
+      class DependencySet
+        def initialize
+          @dependencies = {} 
+          @ctx = {}
+        end
+
+        def apply_to(version_requirement, &blk)
+          @ctx = { version_requirement: version_requirement }
+          instance_eval(&blk) if block_given?
+        ensure
+          @ctx = {}
+        end
+
+        def before_install(&blk)
+          if @ctx[:version_requirement].nil?
+            raise RuntimeError, 'Please call #apply_to prior to #before_install.'
+          end
+          @ctx[:type] = :before_install
+          instance_eval(&blk) if block_given?
+        end
+
+        def after_install(&blk)
+          if @ctx[:version_requirement].nil?
+            raise RuntimeError, 'Please call #apply_to prior to #after_install.'
+          end
+          @ctx[:type] = :after_install
+          instance_eval(&blk) if block_given?
+        end
+
+        def depend_on(name, version:, **opts)
+          if @ctx[:type].nil?
+            raise RuntimeError, 'Please call #before_install or #after_install prior to #depend_on.'
+          end
+          requirement = @ctx[:version_requirement]
+          type = @ctx[:type]
+          dependency = Dependency.new(requirement, type, name, version, **opts)
+          unless @dependencies.has_key?(requirement)
+            @dependencies[requirement] = { before_install: [],
+                                           after_install: [] }
+          end
+          @dependencies[requirement][type] << dependency
+        end
+
+        def dependencies_for(version, type: nil)
+          types = *type
+          types = DependencyTypes if types.empty?
+          deps = { before_install: [],
+                   after_install: [] }
+          @dependencies.each_pair do |r, d|
+            types.each do |t|
+              next if d[t].empty?
+              deps[t] |= d[t] if d[t].first.applicable_to?(version)
+            end
+          end
+          deps
+        end
+
+        def before_install_dependencies_for(version)
+          dependencies_for(version, type: :before_install)
+        end
+
+        def after_install_dependencies_for(version)
+          dependencies_for(version, type: :after_install)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+module Luban
+  module Deployment
+    module Package
+      class Installer < Worker
+        # Shared library file extension name based on OS
+        LibExtensions = { 
+          Linux:  'so',   # Linux
+          Darwin: 'dylib' # OSX 
+        }
+        DefaultLibExtension = 'so'
+
+        attr_reader :configure_opts
+        attr_reader :build_env_vars
+
+        def currently_used_by
+          parent.currently_used_by
+        end
+
+        def current_symlinked?
+          current_package_version == package_version
+        end
+
+        def current_configured?; task.opts.current; end
+        alias_method :current?, :current_configured?
+
+        def current_package_version
+          if symlink?(current_path)
+            File.basename(readlink(current_path))
+          else
+            nil
+          end
+        end
+
+        def default_configure_opts
+          @default_configure_opts ||= []
+        end
+
+        protected
+
+        def init
+          super
+          configure_build_env_variables        
+          configure_build_options
+        end
+
+        def configure_build_env_variables          
+          @build_env_vars = { 
+            ldflags: [ENV['LDFLAGS'].to_s],
+            cflags: [ENV['CFLAGS'].to_s],
+            cppflags: [ENV['CPPFLAGS'].to_s]
+          }
+          if child?
+            configure_parent_build_env_variables
+            configure_parent_build_options
+          end
+        end
+
+        def configure_parent_build_env_variables
+          parent.build_env_vars[:ldflags] << "-L#{lib_path}"
+          parent.build_env_vars[:cflags] << "-I#{include_path}"
+          parent.build_env_vars[:cppflags] << "-I#{include_path}"
+        end
+
+        def configure_parent_build_options
+          if parent.respond_to?("with_#{package_name}_dir")
+            parent.send("with_#{package_name}_dir", install_path)
+          end
+        end
+
+        def compose_build_env_variables
+          build_env_vars.inject({}) do |vars, (k, v)|
+            vars[k] = "'#{v.join(' ').strip}'" unless v.all?(&:empty?)
+            vars
+          end
+        end
+
+        def configure_build_options
+          @configure_opts = default_configure_opts | (task.opts.__remaining__ || [])
+          @configure_opts.unshift(install_prefix)
+        end
+
+        def compose_build_options
+          @configure_opts.reject(&:empty?).join(' ')
+        end
+
+        def install_prefix
+          "--prefix=#{install_path}"
+        end
+
+        def validate; end
+
+        def lib_extension
+          @lib_extension ||= LibExtensions.fetch(os_name.to_sym, DefaultLibExtension)
+        end
+      end
+    end
+  end
+end