vagabund 0.0.20

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

@@ -0,0 +1,123 @@
+module Vagabund
+  module Settler
+    module Projects
+      class ProjectConfig
+        attr_reader :config, :source
+        
+        # Bit of metaprogramming to define methods like builder, installer,
+        # before_build, after_install, etc.
+        %w(project bundler puller).each do |action|
+          %w(before after).each do |hook|
+            hook_action = (action == 'bundler') ? "#{hook}_bundle" : "#{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 |project, machine, channel|
+                  cmd = "cd #{project.project_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 == 'project'
+            alias_method :before, :before_project
+            alias_method :after, :after_project
+            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 |project, machine, channel|
+                cmd = "cd #{project.project_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 == 'bundle') ? 'bundle' : action.gsub(/[eo]r$/, '')}_with".to_sym, action.to_sym
+        end
+        
+        def projects_path
+          config.projects_path ||= '/vagrant'
+        end
+
+        def projects_path=(path)
+          config.projects_path = path
+        end
+        
+        def project_path
+          config.project_path ||= File.join(config.projects_path, name)
+        end
+        alias_method :path, :project_path
+
+        def project_path=(path)
+          config.project_path = path
+        end
+        alias_method :path=, :project_path=
+
+        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(args.extract_options!)
+
+          configure &block if block_given?
+
+          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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+module Vagabund
+  module Settler
+    module Projects
+      class Rails < Ruby
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Vagabund
+  module Settler
+    module Projects
+      class Ruby < Base
+        
+        def provision(machine)
+          exec_before :project, machine
+          pull machine
+          bundle machine
+          exec_after :project, machine
+        end
+        
+        def bundle(machine)
+          exec_before :bundle, machine
+          machine.ui.detail "Bundling #{self.class.name.split('::').last.downcase} project #{name}..."
+          if config.bundler.nil?
+            machine.communicate.execute "cd #{config.project_path}; bundle install" do |type,data|
+              color = type == :stderr ? :red : :green
+              options = {
+                color: color,
+                new_line: false,
+                prefix: false
+              }
+
+              machine.ui.detail(data, options)
+            end
+          else
+            action_exec config.bundler, machine
+          end
+          exec_after :bundle, machine
+        rescue StandardError => e
+          raise Settler::Errors::ProjectError, e
+        end
+
+      end
+    end
+  end
+end

data/lib/vagabund/settler/projects.rb

@@ -0,0 +1,19 @@
+require_relative 'errors'
+require_relative 'projects/base'
+require_relative 'projects/ruby'
+require_relative 'projects/rails'
+
+module Vagabund
+  module Settler
+    module Projects
+    end
+
+    class Project < Projects::Base
+      def self.new(*args, &block)
+        klass = (args.first.is_a?(Symbol) ? args.shift : :base).to_s.capitalize
+        eval("Projects::#{klass}.new *args, &block")
+      end
+    end
+  end
+end
+

data/lib/vagabund/settler/provisioner.rb

@@ -0,0 +1,34 @@
+require_relative 'packages'
+require_relative 'projects'
+require_relative 'sources'
+
+module Vagabund
+  module Settler
+    class Provisioner < Vagrant.plugin(2, :provisioner)
+
+      def provision
+        config.packages.each do |package|
+          begin
+            machine.ui.info "Provisioning package #{package.name}-#{package.version}..."
+            package.provision @machine
+          rescue Vagrant::Errors::VagrantError => e
+            machine.ui.error "Failed to provision package #{package.name}-#{package.version}!"
+            machine.ui.error e.message(false), prefix: false
+            machine.ui.detail "#{e.message} in #{[e.backtrace[0..5], '...'].join($/)}", prefix: false
+          end
+        end
+        
+        config.projects.each do |project|
+          begin
+            machine.ui.info "Provisioning project #{project.name}"
+            project.provision @machine
+          rescue Vagrant::Errors::VagrantError => e
+            machine.ui.error "Failed to provision project #{project.name}!"
+            machine.ui.detail "#{e.message} in #{[e.backtrace[0..5], '...'].join($/)}", prefix: false
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/vagabund/settler/sources/git.rb

@@ -0,0 +1,59 @@
+module Vagabund
+  module Settler
+    module Sources
+      class Git
+        attr_reader :origin
+        
+        def clone(machine, target_path)
+          machine.ui.detail "Cloning #{origin} into #{target_path}..."
+          unless machine.communicate.test "[ -d #{File.dirname(target_path)} ]"
+            machine.communicate.sudo "mkdir -p #{File.dirname(target_path)}"
+            machine.communicate.sudo "chown -R #{machine.ssh_info[:username]} #{File.dirname(target_path)}"
+            machine.communicate.sudo "chgrp -R #{machine.ssh_info[:username]} #{File.dirname(target_path)}"
+          end
+          machine.communicate.execute "git clone #{origin} #{target_path}" do |type,data|
+            color = type == :stderr ? :red : :green
+            options = {
+              color: color,
+              new_line: false,
+              prefix: false
+            }
+
+            machine.ui.detail(data, options)
+          end
+          target_path
+        end
+
+        def update(machine, target_path)
+          machine.ui.detail "Updating #{target_path} from #{origin}..."
+          machine.communicate.execute "cd #{target_path}; git pull" do |type,data|
+            color = type == :stderr ? :red : :green
+            options = {
+              color: color,
+              new_line: false,
+              prefix: false
+            }
+
+            machine.ui.detail(data, options)
+          end
+          target_path
+        end
+
+        def pull(machine, target_path)
+          if machine.communicate.test "[ -d #{target_path} ]"
+            update machine, target_path
+          else
+            clone machine, target_path
+          end
+        end
+
+        protected
+
+        def initialize(origin)
+          @origin = origin
+        end
+      
+      end
+    end
+  end
+end

data/lib/vagabund/settler/sources/local.rb

@@ -0,0 +1,28 @@
+module Vagabund
+  module Settler
+    module Sources
+      class Local
+        attr_reader :origin
+        
+        def upload(machine, target_path)
+          machine.ui.detail "Uploading #{origin} to #{target_path}..."
+          unless machine.communicate.test "[ -d #{File.dirname(target_path)} ]"
+            machine.communicate.sudo "mkdir -p #{File.dirname(target_path)}"
+            machine.communicate.sudo "chown -R #{machine.ssh_info[:username]} #{File.dirname(target_path)}"
+            machine.communicate.sudo "chgrp -R #{machine.ssh_info[:username]} #{File.dirname(target_path)}"
+          end
+          machine.communicate.upload origin, target_path
+          target_path
+        end
+        alias_method :pull, :upload
+
+        protected
+
+        def initialize(origin)
+          @origin = File.expand_path(origin)
+        end
+      
+      end
+    end
+  end
+end

data/lib/vagabund/settler/sources/url.rb

@@ -0,0 +1,37 @@
+module Vagabund
+  module Settler
+    module Sources
+      class Url
+        attr_reader :origin
+        
+        def download(machine, target_path)
+          machine.ui.detail "Downloading #{origin} to #{target_path}..."
+          unless machine.communicate.test "[ -d #{File.dirname(target_path)} ]"
+            machine.communicate.sudo "mkdir -p #{File.dirname(target_path)}"
+            machine.communicate.sudo "chown -R #{machine.ssh_info[:username]} #{File.dirname(target_path)}"
+            machine.communicate.sudo "chgrp -R #{machine.ssh_info[:username]} #{File.dirname(target_path)}"
+          end
+          machine.communicate.execute "curl -L -o #{target_path} #{origin}" do |type,data|
+            color = type == :stderr ? :red : :green
+            options = {
+              color: color,
+              new_line: false,
+              prefix: false
+            }
+
+            machine.ui.detail(data, options)
+          end
+          target_path
+        end
+        alias_method :pull, :download
+
+        protected
+
+        def initialize(origin)
+          @origin = origin
+        end
+      
+      end
+    end
+  end
+end

data/lib/vagabund/settler/sources.rb

@@ -0,0 +1,10 @@
+module Vagabund
+  module Settler
+    module Sources
+    end
+  end
+end
+
+require_relative 'sources/git' 
+require_relative 'sources/url' 
+require_relative 'sources/local'

data/lib/vagabund/settler.rb

@@ -0,0 +1,4 @@
+module Vagabund
+  module Settler
+  end
+end

data/lib/vagabund/squatter/config.rb

@@ -0,0 +1,36 @@
+require_relative 'user'
+
+module Vagabund
+  module Squatter
+    class Config < Vagrant.plugin(2, :config)
+      attr_accessor :guest_home, :host_home
+
+      DEFAULT_FILES = ['.vimrc', '.viminfo', '.gitconfig', '.ssh/known_hosts']
+
+      def files
+        @files ||= DEFAULT_FILES
+      end
+
+      def files=(file_arr)
+        @files = file_arr
+      end
+
+      def file=(filename)
+        files << filename
+      end
+
+      def host_home
+        @host_home ||= File.expand_path('~')
+      end 
+
+      def guest_home
+        @guest_home ||= '~'
+      end
+
+      def user
+        @user ||= User.new
+      end
+
+    end
+  end
+end

data/lib/vagabund/squatter/provisioner.rb

@@ -0,0 +1,199 @@
+module Vagabund
+  module Squatter
+    class Provisioner < Vagrant.plugin(2, :provisioner)
+
+      def configure(root_config)
+        @root_config = root_config
+      end
+
+      def provision
+        create_user
+        upload_files
+      end
+
+      def cleanup
+        # remove the user?
+        super
+      end
+
+      def create_user
+        if config.user.create?
+          if @machine.communicate.test "[ `getent passwd | grep -c '^#{config.user.username}:'` == 0 ]"
+            @machine.ui.info "Creating user #{config.user.username}..."
+            @machine.communicate.sudo config.user.to_s
+
+            # Copy over the authorized_keys and known_hosts files being used currently for compatibility
+            if !@machine.communicate.test "[ -d #{config.user.home}/.ssh ]"
+              ssh_user_home = ''
+              @machine.communicate.execute "echo $HOME" do |type,data|
+                ssh_user_home = data.chomp if type == :stdout
+              end
+              
+              @machine.communicate.sudo "mkdir -p #{config.user.home}/.ssh"
+              
+              if config.user.pubkeys.nil?
+                # Copy the authorized_keys file if it doesn't exist and no public keys were provided
+                if !@machine.communicate.test("[ -f #{config.user.home}/.ssh/authorized_keys ]") && @machine.communicate.test("[ -f #{ssh_user_home}/.ssh/authorized_keys ]")
+                  @machine.communicate.sudo "cp #{ssh_user_home}/.ssh/authorized_keys #{config.user.home}/.ssh/authorized_keys"
+                end
+              else
+                # Add the public key(s) provided
+                @machine.communicate.sudo "echo \"#{config.user.pubkeys}\" > #{config.user.home}/.ssh/authorized_keys"
+              end
+
+              unless config.user.ssh_conf_str.nil?
+                @machine.communicate.sudo "echo \"#{config.user.ssh_conf_str}\" > #{config.user.home}/.ssh/config", verbose: true
+              end
+              
+              if !@machine.communicate.test("[ -f #{config.user.home}/.ssh/known_hosts ]") && @machine.communicate.test("[ -f #{ssh_user_home}/.ssh/known_hosts ]")
+                @machine.communicate.sudo "cp #{ssh_user_home}/.ssh/known_hosts #{config.user.home}/.ssh/known_hosts"
+              end
+              
+              @machine.communicate.sudo "chown -R #{config.user.username} #{config.user.home}/.ssh"
+              @machine.communicate.sudo "chgrp -R #{config.user.username} #{config.user.home}/.ssh"
+            end
+
+            # Add to sudoers
+            if config.user.sudo
+              @machine.communicate.sudo "echo \"#{config.user.username} ALL=(ALL) NOPASSWD:ALL\" > /etc/sudoers.d/#{config.user.username}"
+              @machine.communicate.sudo "chmod 0440 /etc/sudoers.d/#{config.user.username}"
+            end
+          else
+            @machine.ui.warn "User #{config.user.username} already exists"
+          end
+            
+        end
+      rescue
+        @machine.ui.error "Failed to create user #{config.user.username}"
+        @machine.communicate.sudo "userdel -r #{config.user.username}" rescue nil
+        @machine.communicate.sudo "rm -rf /etc/sudoers.d/#{config.user.username}"
+      end
+
+      def upload_files
+        config.files.each do |file|
+          sync *expanded_paths(file)
+        end
+      end
+
+      protected
+
+      def guest_home
+        gh_path = config.guest_home
+        @machine.communicate.execute "cd #{gh_path}; pwd" do |type, data|
+          gh_path = data.chomp if type == :stdout
+        end
+        gh_path
+      end
+
+      def host_home
+        File.expand_path(config.host_home)
+      end
+
+      def expanded_paths(file)
+        # separate source and destination, both expanded relative to home if not absolute
+        if file.is_a?(Array)
+          from = expanded_paths(file[0])[0]
+          to = expanded_paths(file[1])[1]
+
+        # proc should return [from, to]
+        elsif file.is_a?(Proc)
+          from, to = expanded_paths(clean_room.instance_exec(@machine, @machine.communicate, &file))
+
+        # remote source file
+        elsif file.match(/^(http[s]?|s3):\/\//i)
+          from = file
+          to = File.join(guest_home, File.basename(file))
+
+        # already absolute
+        elsif Pathname.new(file).absolute?
+          from = to = file
+
+        # expand path relative to home
+        else
+          from = File.join(host_home, file)
+          to = File.join(guest_home, file)
+        end
+
+        [from, to]
+      end
+
+      def sync(from, to)
+        if from.match(/^(http[s]?|s3):\/\//i)
+          @machine.ui.detail "Downloading #{from}..."
+          Dir.mktmpdir do |dir|
+            from_file = File.join(dir, File.basename(from))
+
+            if from.match(/^http[s]?:\/\//i)
+              `curl -L -o #{from_file} #{from} 2>&1`
+            elsif from.match(/^s3:\/\//i)
+              `aws s3 cp #{from} #{from_file}`
+            end
+
+            upload from_file, to
+          end
+        else
+          unless File.exists?(from)
+            @machine.ui.warn "Local file #{from} does not exist. Skipping."
+            return
+          end
+          upload from, to
+        end
+      end
+
+      def upload(from, to)
+        begin
+          @machine.ui.detail "Uploading #{from} to #{to}..."
+          @machine.communicate.execute "mkdir -p #{File.dirname(to)}" # TODO this should be guest OS agnostic
+          @machine.communicate.upload from, to
+        rescue Vagrant::Errors::VagrantError => e
+          @machine.ui.error "Failed to upload config file #{from} to #{to}"
+          raise e
+        end
+      end
+
+      def clean_room
+        dsl = Struct.new(:machine).new(@machine)
+        dsl.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
+
+        dsl
+      end
+
+    end
+  end
+end

data/lib/vagabund/squatter/user.rb

@@ -0,0 +1,56 @@
+module Vagabund
+  module Squatter
+    class User
+      attr_accessor :username, :password, :home, :shell, :group, :groups, :sudo, :public_key, :ssh_config
+
+      def home
+        @home || "/home/#{username}"
+      end
+
+      def shell
+        @shell ||= "/bin/bash"
+      end
+
+      def pubkeys
+        unless @public_key.nil?
+          [@public_key].flatten.map do |pubkey|
+            begin
+              File.read(File.expand_path(pubkey)).chomp
+            rescue Exception => e
+              pubkey
+            end
+          end.join($/)
+        end
+      end
+
+      def ssh_conf_str
+        unless @ssh_config.nil?
+          begin
+            File.read(File.expand_path(@ssh_config)).chomp
+          rescue Exception => e
+            @ssh_config
+          end
+        end
+      end
+
+      def to_s
+        cmd_str = "useradd -m -s #{shell}"
+        cmd_str += " -d #{home}"
+        cmd_str += " -g #{group}" unless group.nil?
+        cmd_str += " -G #{[groups].flatten.join(',')}" unless groups.nil?
+        cmd_str += " #{username}"
+      end
+
+      def create?
+        !username.nil?
+      end
+
+      protected
+
+      def initialize
+        @sudo = true
+      end
+
+    end
+  end
+end

data/lib/vagabund/squatter.rb

@@ -0,0 +1,4 @@
+module Vagabund
+  module Squatter
+  end
+end

data/lib/vagabund/version.rb

@@ -0,0 +1,3 @@
+module Vagabund
+  VERSION = "0.0.20"
+end