vagabund 0.0.20

data/lib/vagabund/settler/errors.rb

@@ -0,0 +1,48 @@
+module Vagabund
+  module Settler
+    module Errors
+      class SettlerError < Vagrant::Errors::VagrantError
+        attr_reader :original_error
+
+        error_namespace "vagabund.settler.errors"
+
+        def message(orig=true)
+          return super() if !orig || original_error.nil?
+          "#{original_error.class.name}: #{original_error.message}"
+        end
+
+        def backtrace(orig=true)
+          !orig || original_error.nil? ? super() : original_error.backtrace
+        end
+
+        def initialize(*args)
+          @original_error = args.shift if args.first.is_a?(Exception)
+          super(*args)
+        end
+      end
+
+      class PackageError < SettlerError; end
+      class ProjectError < SettlerError; end
+
+      class PackageBuildError < PackageError
+        error_key :package_build_error
+      end
+      
+      class PackageCleanError < PackageError
+        error_key :package_clean_error
+      end
+
+      class PackageExtractionError < PackageError
+        error_key :package_extraction_error
+      end
+      
+      class PackageInstallError < PackageError
+        error_key :package_install_error
+      end
+      
+      class PackagePullError < PackageError
+        error_key :package_pull_error
+      end
+    end
+  end
+end

data/lib/vagabund/settler/packages/base.rb

@@ -0,0 +1,215 @@
+require_relative 'package_config'
+
+module Vagabund
+  module Settler
+    module Packages
+      class Base
+        attr_reader :config
+
+        def provision(machine)
+          exec_before :package, machine
+
+          if skip?
+            machine.ui.warn "Skipping package #{name}-#{version} because skip flag was set."
+            return
+          end
+
+          pull machine
+          extract machine
+          build machine
+          install machine
+          clean machine
+
+          exec_after :package, machine
+        end
+
+        def build(machine)
+          exec_before :build, machine
+          machine.ui.detail "Building #{name}-#{version}..."
+          action_exec config.builder, machine
+          exec_after :build, machine
+        rescue StandardError => e
+          raise Settler::Errors::PackageBuildError, e
+        end
+
+        def clean(machine)
+          exec_before :clean, machine
+          machine.ui.detail "Cleaning up after #{name}-#{version}..."
+          action_exec config.cleaner, machine
+          exec_after :clean, machine
+        rescue StandardError => e
+          raise Settler::Errors::PackageCleanError, e
+        end
+
+        def extract(machine)
+          exec_before :extract, machine
+          machine.ui.detail "Unpacking #{name}-#{version}..."
+          action_exec config.extractor, machine
+          exec_after :extract, machine
+        rescue StandardError => e
+          raise Settler::Errors::PackageExtractionError, e
+        end
+
+        def install(machine)
+          exec_before :install, machine
+          machine.ui.detail "Installing #{name}-#{version}..."
+          action_exec config.installer, machine
+          exec_after :install, machine
+        rescue StandardError => e
+          raise Settler::Errors::PackageInstallError, e
+        end
+
+        def pull(machine)
+          exec_before :pull, machine
+          machine.ui.detail "Retrieving sources for #{name}-#{version}..."
+          action_exec config.puller, machine
+          exec_after :pull, machine
+        rescue StandardError => e
+          raise Settler::Errors::PackagePullError, e
+        end
+
+        def exec_before(action, machine)
+          hook_exec :before, action, machine
+        end
+
+        def exec_after(action, machine)
+          hook_exec :after, action, machine
+        end
+
+        def hook_exec(hook, action, machine)
+          hook_action = "#{hook.to_s}_#{action.to_s.gsub(/[eo]r$/, '')}"
+          return if config.send(hook_action).nil? || config.send(hook_action).empty?
+
+          machine.ui.detail "Executing custom :#{hook_action} hooks for package #{name}-#{version}..."
+          config.send(hook_action).each do |hact|
+            action_exec hact, machine
+          end
+        rescue StandardError => e
+          raise Settler::Errors::PackageError, e
+        end
+
+        def action_exec(command, machine)
+          self.class.instance_eval do
+            [:ask, :detail, :error, :info, :output, :warn].each do |cmd|
+              define_method cmd do |*args, &block|
+                machine.ui.send cmd, *args, &block
+              end
+            end
+
+            [:execute, :sudo, :test].each do |cmd|
+              define_method cmd do |*args, &block|
+                opts = {verbose: false}.merge(args.extract_options!)
+                if opts[:verbose] == true
+                  machine.communicate.send cmd, *args, opts do |type,data|
+                    color = type == :stderr ? :red : :green
+                    options = {
+                      color: color,
+                      new_line: false,
+                      prefix: false
+                    }
+
+                    detail(data, options)
+                    block.call(type, data) unless block.nil?
+                  end
+                else
+                  machine.communicate.send cmd, *args, opts, &block
+                end
+              end
+            end
+
+            define_method :capture do |*args, &block|
+              output = ''
+              machine.communicate.execute *args do |type,data|
+                output += data if type == :stdout
+                block.call(type, data) unless block.nil?
+              end
+              output
+            end
+          end
+
+          instance_exec self, machine, machine.communicate, &command if command.is_a?(Proc)
+
+          self.class.instance_eval do
+            [:ask, :detail, :error, :info, :output, :warn, :capture, :execute, :sudo, :test].each do |cmd|
+              undef_method cmd
+            end
+          end
+        end
+
+        def configure(&block)
+          config.configure &block
+        end
+
+        def local_package
+          config.local_package
+        end
+        alias_method :local_file, :local_package
+
+        def build_path
+          config.build_path
+        end
+
+        def build_root
+          config.build_root
+        end
+
+        def name
+          config.name
+        end
+
+        def version
+          config.version
+        end
+
+        def source
+          config.source
+        end
+
+        def skip(s)
+          @skip = s unless s.nil?
+          @skip
+        end
+        alias_method :skip=, :skip
+
+        def skip?
+          @skip
+        end
+
+        protected
+
+        #
+        # Base.new 'poppler', '0.24.5', {url: 'http://poppler.freedesktop.org/poppler-0.24.5.tar.xz'}
+        #
+        # Supported source types:
+        #   git: 'git url'
+        #   local: '/path/to/local/file'
+        #   url: 'http://example.com/path/to/file'
+        #   url: 'ftp://user:pass@example.com/path/to/file'
+        #   scp: '[user@]example.com:/path/to/file' # this might require ssh forwarding
+        def initialize(*args, &block)
+          opts = args.extract_options!
+          opts = {name: args.shift, version: args.shift}.merge(opts)
+          @config = PackageConfig.new(opts, &block)
+        end
+
+        def build_path_exists?(machine)
+          return machine.communicate.test("[ -d #{build_path} ]") ? true : false
+        end
+
+        def package_exists?(machine)
+          return machine.communicate.test("[ -f #{existing_package_file(machine)} ]") ? true : false
+        end
+
+        def existing_package_file(machine)
+          pkg_file = local_file
+
+          while !machine.communicate.test("[ -f #{pkg_file} ]") && !File.extname(pkg_file).empty? do
+            pkg_file = File.join(build_root, File.basename(pkg_file, File.extname(pkg_file)))
+          end
+          pkg_file
+        end
+
+      end
+    end
+  end
+end

data/lib/vagabund/settler/packages/config.rb

@@ -0,0 +1,39 @@
+module Vagabund
+  module Settler
+    module Packages
+      class Config
+
+        def packages
+          @packages ||= []
+        end
+
+        def add_package(*args, &block)
+          if args.first.is_a?(Packages::Base)
+            pkg = args.shift
+            pkg.configure &block if block_given?
+            packages << pkg
+          else
+            add_package Package.new(*args, &block)
+          end
+        end
+        alias_method :package, :add_package
+        alias_method :package=, :add_package
+
+        def method_missing(meth, *args, &block)
+          packages.send meth, *args, &block
+        end
+        
+        def respond_to_missing?(meth, include_private=false)
+          packages.respond_to? meth, include_private
+        end
+
+        protected
+
+        def initialize(*args)
+          @settler_config = args.shift if args.first.is_a?(Settler::Config)
+          @packages = args.shift if args.first.is_a?(Array)
+        end
+      end
+    end
+  end
+end

data/lib/vagabund/settler/packages/package_config.rb

@@ -0,0 +1,118 @@
+module Vagabund
+  module Settler
+    module Packages
+      class PackageConfig
+        attr_reader :config, :source
+        
+        # Bit of metaprogramming to define methods like builder, installer,
+        # before_build, after_install, etc.
+        %w(package builder cleaner extractor installer puller).each do |action|
+          %w(before after).each do |hook|
+            hook_action = "#{hook}_#{action.gsub(/[eo]r$/, '')}"
+
+            # Defines before/after 'hook' methods for each action: before_build,
+            # before_pull, after_install, etc.
+            define_method hook_action.to_sym do |*args, &block|
+              if args.first.is_a?(String)
+                command = args.shift
+                opts = args.extract_options!
+
+                cmd_proc = Proc.new do |package, machine, channel|
+                  cmd = "cd #{package.build_path}; #{command}"
+                  execute cmd, {verbose: true}.merge(opts)
+                end
+
+                config.send "#{hook_action}=".to_sym, [] if config.send(hook_action.to_sym).nil?
+                config.send(hook_action.to_sym) << cmd_proc
+              end
+
+              if !args.empty? && (args.first.nil? || args.first.is_a?(Proc))
+                config.send "#{hook_action}=".to_sym, [] if config.send(hook_action.to_sym).nil?
+                config.send(hook_action.to_sym) << args.shift
+              end
+
+              if !block.nil? # block_given? doesn't work here
+                config.send "#{hook_action}=".to_sym, [] if config.send(hook_action.to_sym).nil?
+                config.send(hook_action.to_sym) << block
+              end
+
+              config.send "#{hook_action}".to_sym
+            end
+          end
+
+          if action == 'package'
+            alias_method :before, :before_package
+            alias_method :after, :after_package
+            next
+          end
+
+          # Defines custom action methods to override the built-in puller,
+          # extractor, builder, installer and cleaner.
+          define_method action.to_sym do |*args, &block|
+            if args.first.is_a?(String)
+              command = args.shift
+              opts = args.extract_options!
+
+              cmd_proc = Proc.new do |package, machine, channel|
+                cmd = "cd #{package.build_path}; #{command}"
+                execute cmd, {verbose: true}.merge(opts)
+              end
+
+              config.send "#{action}=".to_sym, cmd_proc
+            end
+
+            config.send "#{action}=".to_sym, args.shift if !args.empty? && (args.first.nil? || args.first.is_a?(Proc))
+            config.send "#{action}=".to_sym, block if !block.nil? # block_given? doesn't work here
+
+            config.send action.to_sym
+          end
+          alias_method "#{action}=".to_sym, action.to_sym
+          alias_method "#{action.gsub(/[eo]r$/, '')}_with".to_sym, action.to_sym
+        end
+
+        def build_root
+          config.build_root ||= "/tmp/#{name}-#{version}"
+        end
+
+        def build_path
+          config.build_path ||= File.join(build_root, "#{name}-#{version}")
+        end
+
+        def local_package
+          config.local_package ||= File.join(build_root, (File.basename(source.origin) rescue "#{name}-#{version}"))
+        end
+        alias_method :local_file, :local_package
+
+        def configure(&block)
+          instance_eval &block if block_given?
+        end
+
+        def method_missing(meth, *args, &block)
+          config.send meth, *args, &block
+        end
+
+        def respond_to_missing?(meth, include_private=false)
+          config.respond_to? meth, include_private
+        end
+
+        protected
+
+        def initialize(*args, &block)
+          @config = OpenStruct.new({builder: Package::BUILDER, cleaner: Package::CLEANER, extractor: Package::EXTRACTOR, installer: Package::INSTALLER, puller: Package::PULLER}.merge(args.extract_options!))
+
+          if config.respond_to?(:git)
+            @source = Sources::Git.new(config.git)
+          elsif config.respond_to?(:url)
+            @source = Sources::Url.new(config.url)
+          elsif config.respond_to?(:local)
+            @source = Sources::Local.new(config.local)
+          #elsif config.respond_to?(:scp)
+            # remote scp
+          end
+
+          configure &block if block_given?
+        end
+      end
+    end
+  end
+end

data/lib/vagabund/settler/packages.rb

@@ -0,0 +1,101 @@
+require_relative 'errors'
+require_relative 'packages/base'
+
+module Vagabund
+  module Settler
+    module Packages
+    end
+
+    class Package < Packages::Base
+      EXTENSIONS = ['.gz', '.bz', '.bz2', '.xz', '.zip', '.tar', '.tgz', '.tbz', '.tbz2', '.txz']
+
+      BUILDER = Proc.new do |package, machine, channel|
+        execute "cd #{build_path}; ./configure && make", verbose: true
+      end
+
+      CLEANER = Proc.new do |package, machine, channel|
+        sudo "rm -rf #{build_root}"
+      end
+
+      EXTRACTOR = Proc.new do |package, machine, channel|
+        if build_path_exists?(machine)
+          machine.ui.warn "Build path #{build_path} already exists, using it for the build. If you would like to use a clean source tree, you should manually remove it and run `vagrant provision` again."
+        elsif File.directory?(local_package)
+          execute "cp -r #{local_package} #{build_path}" if local_package != build_path
+        else
+          execute "mkdir -p #{build_path}"
+          local_ext = File.extname(local_package)
+
+          case local_ext
+          when '.gz'
+            execute "cd #{build_root}; gzip -dc #{local_package} > #{build_path}/#{File.basename(local_package, local_ext)}"
+          when '.tgz'
+            execute "cd #{build_root}; gzip -dc #{local_package} > #{build_path}/#{File.basename(local_package, local_ext)}.tar"
+          when '.bz', '.bz2'
+            execute "cd #{build_root}; bzip2 -dc #{local_package} > #{build_path}/#{File.basename(local_package, local_ext)}"
+          when '.tbz', '.tbz2'
+            execute "cd #{build_root}; bzip2 -dc #{local_package} > #{build_path}/#{File.basename(local_package, local_ext)}.tar"
+          when '.xz'
+            execute "cd #{build_root}; xz -dc #{local_package} > #{build_path}/#{File.basename(local_package, local_ext)}"
+          when '.txz'
+            execute "cd #{build_root}; xz -dc #{local_package} > #{build_path}/#{File.basename(local_package, local_ext)}.tar"
+          when '.zip'
+            execute "cd #{build_root}; unzip #{local_package} -d #{build_path}"
+            execute("cd #{build_path}; mv #{File.basename(local_package, local_ext)}/* ./") rescue nil
+            execute("cd #{build_path}; mv #{File.basename(local_package, local_ext)}/.* ./") rescue nil
+            execute("cd #{build_path}; mv #{name}-#{version}/* ./") rescue nil
+            execute("cd #{build_path}; mv #{name}-#{version}/.* ./") rescue nil
+            execute("cd #{build_path}; rm -rf #{File.basename(local_package, local_ext)}") rescue nil
+          when '.tar'
+            begin
+              execute "cd #{build_root}; tar xf #{local_package} #{File.basename(local_package, local_ext)} -C #{build_path}"
+            rescue
+              begin
+                execute "cd #{build_root}; tar xf #{local_package} #{name}-#{version} -C #{build_path}"
+              rescue
+                execute "cd #{build_root}; tar xf #{local_package} -C #{build_path}"
+              end
+            end
+          end
+
+          build_files = ""
+          execute "cd #{build_path}; ls" do |type, data|
+            build_files = data
+          end
+
+          if build_files.split($/).length == 1
+            new_package_file = File.basename(build_files.chomp)
+            if Package::EXTENSIONS.include?(File.extname(new_package_file))
+              execute "mv #{File.join(build_path, new_package_file)} #{build_root}"
+              sudo    "rm -rf #{local_package} #{build_path}"
+              config.local_package = File.join(build_root, new_package_file)
+              
+              # Re-execute this proc directly instead of going back through extract() or action_exec()
+              detail "Unpacking #{local_package}..."
+              instance_exec self, machine, machine.communicate, &EXTRACTOR
+            end
+          end
+
+        end
+      end
+
+      INSTALLER = Proc.new do |package, machine, channel|
+        sudo "cd #{build_path}; make install", verbose: true
+      end
+
+      PULLER = Proc.new do |package, machine, channel|
+        if package_exists?(machine)
+          config.local_package = existing_package_file(machine)
+          machine.ui.warn "Package #{local_package} already exists, using it for the build. If you would like to re-download the package, you should manually remove it then run `vagrant provision` again."
+        else
+          source.pull machine, local_package
+        end
+      end
+
+      def self.new(*args, &block)
+        Packages::Base.new(*args, &block)
+      end
+    end
+  end
+end
+

data/lib/vagabund/settler/projects/base.rb

@@ -0,0 +1,120 @@
+require_relative 'project_config'
+
+module Vagabund
+  module Settler
+    module Projects
+      class Base
+        attr_reader :config
+
+        def provision(machine)
+          exec_before :project, machine
+          pull machine
+          exec_after :project, machine
+        end
+
+        def pull(machine)
+          exec_before :pull, machine
+          if config.puller.nil?
+            config.source.pull machine, project_path
+          else
+            action_exec config.puller, machine
+          end
+          exec_after :pull, machine
+        rescue StandardError => e
+          raise Settler::Errors::ProjectError, e
+        end
+        
+        def exec_before(action, machine)
+          hook_exec :before, action, machine
+        end
+
+        def exec_after(action, machine)
+          hook_exec :after, action, machine
+        end
+
+        def hook_exec(hook, action, machine)
+          hook_action = "#{hook.to_s}_#{action.to_s.gsub(/[eo]r$/, '')}"
+          return if config.send(hook_action).nil? || config.send(hook_action).empty?
+
+          machine.ui.detail "Executing custom :#{hook_action} hooks for project #{name}..."
+          config.send(hook_action).each do |hact|
+            action_exec hact, machine
+          end
+        rescue StandardError => e
+          raise Settler::Errors::ProjectError, e
+        end
+
+        def action_exec(command, machine)
+          self.class.instance_eval do
+            [:ask, :detail, :error, :info, :output, :warn].each do |cmd|
+              define_method cmd do |*args, &block|
+                machine.ui.send cmd, *args, &block
+              end
+            end
+            [:execute, :sudo, :test].each do |cmd|
+              define_method cmd do |*args, &block|
+                opts = {verbose: false}.merge(args.extract_options!)
+                if opts[:verbose] == true
+                  machine.communicate.send cmd, *args, opts do |type,data|
+                    color = type == :stderr ? :red : :green
+                    options = {
+                      color: color,
+                      new_line: false,
+                      prefix: false
+                    }
+
+                    detail(data, options)
+                    block.call(type, data) unless block.nil?
+                  end
+                else
+                  machine.communicate.send cmd, *args, opts, &block
+                end
+              end
+            end
+
+            define_method :capture do |*args, &block|
+              output = ''
+              machine.communicate.execute *args do |type,data|
+                output += data if type == :stdout
+                block.call(type, data) unless block.nil?
+              end
+              output
+            end
+          end
+
+          instance_exec self, machine, machine.communicate, &command if command.is_a?(Proc)
+
+          self.class.instance_eval do
+            [:ask, :detail, :error, :info, :output, :warn, :capture, :execute, :sudo, :test].each do |cmd|
+              undef_method cmd
+            end
+          end
+        end
+        
+        def configure(&block)
+          config.configure &block
+        end
+
+        def name
+          config.name
+        end
+
+        def project_path
+          config.project_path
+        end
+
+        protected
+
+        #
+        # Base.new 'my_project', {git: 'git@github.com:/user/repo.git'}
+        #
+        def initialize(*args, &block)
+          opts = args.extract_options!
+          opts = {name: args.shift}.merge(opts)
+          @config = ProjectConfig.new(opts, &block)
+        end
+
+      end
+    end
+  end
+end

data/lib/vagabund/settler/projects/config.rb

@@ -0,0 +1,51 @@
+module Vagabund
+  module Settler
+    module Projects
+      class Config
+
+        def projects_path
+          @projects_path ||= '/vagrant'
+        end
+        alias_method :path, :projects_path
+
+        def projects_path=(path)
+          @projects_path = path
+        end
+        alias_method :path=, :projects_path=
+
+        def projects
+          @projects ||= []
+        end
+
+        def add_project(*args, &block)
+          if args.first.is_a?(Projects::Base)
+            prj = args.shift
+            prj.config.projects_path ||= projects_path
+            prj.configure &block if block_given?
+            projects << prj
+          else
+            args.push({projects_path: projects_path}.merge(args.extract_options!))
+            add_project Project.new(*args, &block)
+          end
+        end
+        alias_method :project, :add_project
+        alias_method :project=, :add_project
+
+        def method_missing(meth, *args, &block)
+          projects.send meth, *args, &block
+        end
+        
+        def respond_to_missing?(meth, include_private=false)
+          projects.respond_to? meth, include_private
+        end
+
+        protected
+
+        def initialize(*args)
+          @settler_config = args.shift if args.first.is_a?(Settler::Config)
+          @projects = args.shift if args.first.is_a?(Array)
+        end
+      end
+    end
+  end
+end