engineyard-local 0.2.1

data/lib/engineyard-local/middleware/rails.rb

@@ -0,0 +1,3 @@
+require "engineyard-local/middleware/rails/db"
+require "engineyard-local/middleware/rails/command"
+require "engineyard-local/middleware/rails/install"

data/lib/engineyard-local/middleware/rails/command.rb

@@ -0,0 +1,31 @@
+module Engineyard
+  module Local
+    module Middleware
+      module Rails
+        class Command
+          include Middleware::Helpers::Rvm
+          include Middleware::Helpers::Executable
+
+          def initialize(app, env)
+            @app, @env = app, env
+          end
+
+          def call(env)
+            ssh_exec!(env, commands)
+            @app.call(env)
+          end
+
+          def commands
+            rvm_env +
+              [ "cd #{project_dir}",
+                "rails #{command_args}" ]
+          end
+
+          def command_args
+            @env["eylocal.rails.command_args"].join(" ")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/engineyard-local/middleware/rails/db.rb

@@ -0,0 +1,36 @@
+module Engineyard
+  module Local
+    module Middleware
+      module Rails
+        class DB
+          include Middleware::Helpers::Rvm
+          include Middleware::Helpers::Executable
+
+          def initialize(app, env)
+            @app = app
+            @env = env
+          end
+
+          def call(env)
+            @env[:ui].info I18n.t("eylocal.setup.rails.db")
+            ssh_exec!(env, commands)
+            @app.call(env)
+          end
+
+          def commands
+            rvm_env +
+              [ "cd #{project_dir}",
+                if_task_exists("db:create"),
+                if_task_exists("db:migrate") ]
+          end
+
+          # if there's a Rakefile, and rake -T contains the task we're looking for
+          # execute the task
+          def if_task_exists(task)
+            "if [[ `rake -T > /dev/null 2>&1 && rake -T | grep -e '#{task}'` ]]; then rake #{task}; fi"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/engineyard-local/middleware/rails/install.rb

@@ -0,0 +1,36 @@
+module Engineyard
+  module Local
+    module Middleware
+      module Rails
+        class Install
+          include Middleware::Helpers::Rvm
+          include Middleware::Helpers::Executable
+
+          def initialize(app, env)
+            @app, @env = app, env
+          end
+
+          def call(env)
+            ssh_exec!(env, commands)
+            @app.call(env)
+          end
+
+          def commands
+            rvm_env +
+              [ unless_rails("gem install rails #{install_opts}") ]
+          end
+
+          def install_opts
+            if @env["eylocal.rails.version"]
+              "--version=#{@env["eylocal.rails.version"]}"
+            end
+          end
+
+          def unless_rails(cmd)
+            "gem list rails | grep rails; if [[ $? -gt 0 ]]; then sudo #{cmd}; fi"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/engineyard-local/middleware/rails/new.rb

@@ -0,0 +1,31 @@
+module Engineyard
+  module Local
+    module Middleware
+      module Rails
+        class New
+          include Middleware::Helpers::Rvm
+          include Middleware::Helpers::Executable
+
+          def initialize(app, env, opts)
+            @app, @env, @opts = app, env, opts
+          end
+
+          def call(env)
+            ssh_exec!(env, commands)
+            @app.call(env)
+          end
+
+          def commands
+            rvm_env +
+              [ "cd #{project_dir}",
+                "rails #{command_args}" ]
+          end
+
+          def command_args
+            @opts["eylocal.rails.command_args"].join(" ")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/engineyard-local/middleware/tag.rb

@@ -0,0 +1,33 @@
+require 'digest/sha1'
+
+module Engineyard
+  module Local
+    module Middleware
+      class Tag
+        include Helpers::Network
+
+        def initialize(app, env)
+          @app, @env = app, env
+        end
+
+        def call(env)
+          @env[:ui].info I18n.t("eylocal.tag")
+          tag_vm(env)
+          @app.call(env)
+        end
+
+        def tag_vm(env)
+          value = env[:root_path].to_s
+
+          # mark the vm as ey-local for listing
+          set_extra_data(env, Local.config[:managed_vm_key], value)
+          set_extra_data(env, Local.config[:network_ip_key], proposed_ip)
+        end
+
+        def set_extra_data(env, key, value)
+          env[:vm].driver.execute("setextradata", env[:vm].uuid, key, value)
+        end
+      end
+    end
+  end
+end

data/lib/engineyard-local/ui.rb

@@ -0,0 +1,33 @@
+module Engineyard
+  module Local
+    module UI
+      module Common
+        def ey_localize(message)
+          # TODO this is likely to be insufficient but it's a start
+          #      toward making sure the ui is consistent for the user
+          message.gsub(/([Aa]) (`)?[Vv]agrant /, '\1n \2ey-local ').gsub(/[Vv]agrant /, 'ey-local ')
+        end
+
+        def say(type, message, opts=nil)
+          super(type, ey_localize(message), opts)
+        end
+      end
+
+      class Basic < Vagrant::UI::Basic
+        include Common
+
+        def initialize(resource)
+          super(Local.config[:commands][:prefix])
+        end
+      end
+
+      class Colored < Vagrant::UI::Colored
+        include Common
+
+        def initialize(resource)
+          super(Local.config[:commands][:prefix])
+        end
+      end
+    end
+  end
+end

data/lib/engineyard-local/version.rb

@@ -0,0 +1,5 @@
+module Engineyard
+  module Local
+    VERSION = "0.2.1"
+  end
+end

data/lib/engineyard-local/virtualbox.rb

@@ -0,0 +1,35 @@
+module Engineyard
+  module Local
+    class Virtualbox
+      VALUE_PREFIX = "Value: "
+      # TODO this is exceptionally difficult to read
+      INFO_REGEX = /"(.*)".*\{(.*)\}/
+
+      def self.uuid_map
+        # TODO ~~~ is fragile
+        # extract the uuids from `VBoxMange list vms`, sample output:
+        #   "Bar VM" {c21b5de6-5867-4471-ab53-7af23badc5eb}
+        #   "Foo VM" {aaba8c3a-3521-46e2-bd2c-fe7e65b77524}
+        info_list = vbox.execute("list", "vms").gsub(INFO_REGEX, '\1~~~\2').split("\n")
+
+        info_list.inject({}) do |acc, info|
+          name, uuid = info.split("~~~")
+          acc[name] = uuid
+          acc
+        end
+      end
+
+      def self.extra_data(uuid, key = "enumerate" )
+        value = vbox.execute("getextradata", uuid, key).strip
+
+        if value.include?(VALUE_PREFIX)
+          value.gsub!(/#{VALUE_PREFIX}/, '')
+        end
+      end
+
+      def self.vbox
+        @@vbox ||= Vagrant::Driver::VirtualBox.new
+      end
+    end
+  end
+end

data/lib/vagrant_init.rb

@@ -0,0 +1 @@
+require "engineyard-local"

data/test/engineyard-local/command/group_test.rb

@@ -0,0 +1,34 @@
+require "test_helper"
+
+class CommandGroupTest < Test::Unit::TestCase
+  include Vagrant::TestHelpers
+
+  context "log" do
+    setup do
+      @cmd = Engineyard::Local::Command::Group.new([], {}, {:env => @env})
+      @klass = Engineyard::Local::Command::Group
+      @app, @env = action_env
+      @klass.env = @env
+      @cmd.stubs(:options).returns({"lines" => 100, "environment" => "development"})
+    end
+
+    should "exec tail with flagged lines" do
+      Engineyard::Local::Command::Exec
+        .any_instance.expects(:run)
+        .with(Engineyard::Local::Middleware::Exec, { "eylocal.exec.command_args" => ["tail -10 log/development.log"]})
+
+
+      @cmd.expects(:options).twice.returns({"lines" => 10, "environment" => "development"})
+      @cmd.log()
+    end
+
+    should "exec tail with flagged environment" do
+      Engineyard::Local::Command::Exec
+        .any_instance.expects(:run)
+        .with(Engineyard::Local::Middleware::Exec, { "eylocal.exec.command_args" => ["tail -100 log/foo.log"]})
+
+      @cmd.expects(:options).twice.returns({"lines" => 100, "environment" => "foo"})
+      @cmd.log()
+    end
+  end
+end

data/test/engineyard-local/command/up_test.rb

@@ -0,0 +1,70 @@
+require "test_helper"
+
+class CommandUpTest < Test::Unit::TestCase
+  include Vagrant::TestHelpers
+
+  context "up" do
+    setup do
+      @klass = Engineyard::Local::Command::Up
+      @config = Engineyard::Local.config
+      @env = vagrant_env
+
+      # TODO this is clearly bad, using env.cli in the commands
+      #      makes it hard to mock/expect
+      @cmd = Engineyard::Local::Command::Group.new([], {}, {:env => @env})
+
+      # prevent the bundle middleware from executing
+      @klass.any_instance.stubs(:with_target_vms).returns([])
+      @klass.any_instance.stubs(:env).returns(@env)
+
+      @env.stubs(:cli)
+      @env.stubs(:root_path).returns(nil)
+    end
+
+    should "add a box with config default params when invoked" do
+      default_name = @config[:box_defaults][:name]
+      default_uri = @config[:box_defaults][:uri]
+
+      @env.expects(:cli).with("box", "add", default_name, default_uri)
+      @env.expects(:cli).with("init", default_name)
+      @cmd.up
+    end
+
+    should "add a box with passed params when invoked" do
+      name = "foo"
+      uri = "http://foo.com"
+
+      @env.expects(:cli).with("box", "add", name, uri)
+      @env.expects(:cli).with("init", name)
+      @cmd.up(name, uri)
+    end
+
+    should "default to the installed box when its preset" do
+      default_name = @config[:box_defaults][:name]
+
+      Engineyard::Local.expects(:project_root).returns("/foo/")
+      File.expects(:exists?).with("/foo/default.box").returns(true)
+
+      @env.expects(:cli).with("box", "add", default_name, "/foo/default.box")
+      @env.expects(:cli).with("init", default_name)
+      @cmd.up
+    end
+
+    context "bundling" do
+      setup do
+        @env.stubs(:cli)
+        Vagrant::Action::Builder.any_instance.stubs(:use)
+      end
+
+      should "skip bundle when --no-bundle is included on the cli" do
+        Vagrant::Action::Builder.any_instance.expects(:use).with(Engineyard::Local::Middleware::Bundle).never
+        @cmd.up("--no-bundle")
+      end
+
+      should "run bundle by default" do
+        Vagrant::Action::Builder.any_instance.expects(:use).with(Engineyard::Local::Middleware::Bundle)
+        @cmd.up
+      end
+    end
+  end
+end

data/test/engineyard-local/command_test.rb

@@ -0,0 +1,40 @@
+require "test_helper"
+
+class CommandTest < Test::Unit::TestCase
+  include Vagrant::TestHelpers
+
+  context "Command" do
+    setup do
+      @klass = Engineyard::Local::Command
+      @cmdgrp = Engineyard::Local::Command::Group
+      @klass.stubs(:passthrough).returns(["foo"])
+      @klass.stubs(:all).returns(["foo", "bar"])
+
+      @app, @env = action_env
+      @klass.stubs(:vagrant_env).returns(@env)
+    end
+
+    should "not start Thor when command is member of passthrough set" do
+      # add description for the expected method below to prevent
+      # thor warning
+      @cmdgrp.desc("foo", "desc")
+
+      @cmdgrp.any_instance.expects(:foo).once
+      @cmdgrp.expects(:start).never
+
+      @klass.dispatch(["foo"])
+    end
+
+    should "start thor when the command is not passthrough" do
+      @cmdgrp.expects(:start).once
+
+      @klass.dispatch(["bar"])
+    end
+
+    should "return false when the command isn't included defined by ey-local" do
+      args = ["not-there-at-all"]
+      @env.expects(:cli).with(args)
+      assert !@klass.dispatch(args)
+    end
+  end
+end

data/test/engineyard-local/middelware/bundle_test.rb

@@ -0,0 +1,32 @@
+require "test_helper"
+
+class BundleTest < Test::Unit::TestCase
+  include Vagrant::TestHelpers
+  include Engineyard::Local::TestHelpers
+
+  context "bundle" do
+    setup do
+      @app, @env = action_env
+      @middleware = Engineyard::Local::Middleware::Bundle.new(@app, @env)
+    end
+
+    should "provide the project directory" do
+      # TODO reference default config
+      assert_equal(@middleware.project_dir, "/vagrant")
+    end
+
+    should "setup the users environment for the ssh session (rvm)" do
+      assert(joined_commands.include?("/etc/profile.d/"))
+    end
+
+    should "set the rvm environment and gemset" do
+      # rvm command
+      assert(joined_commands.include?("rvm use"))
+    end
+
+    should "execute the commands necessary to install bundle in the app gemset" do
+      mock_ssh_channel(@env).expects(:execute).with(joined_commands)
+      @middleware.call(@env)
+    end
+  end
+end

data/test/engineyard-local/middelware/default_provisioner_test.rb

@@ -0,0 +1,35 @@
+require "test_helper"
+
+class DefaultProvisionerTest < Test::Unit::TestCase
+  include Vagrant::TestHelpers
+  include Engineyard::Local::TestHelpers
+
+  context "defaulting the provisioner" do
+    setup do
+      @app, @env = action_env
+      @middleware = Engineyard::Local::Middleware::DefaultProvisioner.new(@app, @env)
+    end
+
+    should "not alter the provisioners list when the recipe doesn't exist" do
+      @middleware.expects(:default_recipe_path).returns("/will-not-exist")
+      @env[:vm].config.vm.expects(:provision).never
+      @middleware.call(@env)
+    end
+
+    should "not alter the provisioners list when another is configured" do
+      # ensure file check passes
+      @middleware.expects(:default_recipe_path).returns(File.expand_path(__FILE__))
+      @middleware.expects(:provisioner_configured?).returns(true)
+      @env[:vm].config.vm.expects(:provision).never
+      @middleware.call(@env)
+    end
+
+    should "add a provisioner when the recipe exists and there are no other provisioners" do
+      # ensure file check passes, called twice for the ui output
+      @middleware.expects(:default_recipe_path).twice.returns(File.expand_path(__FILE__))
+      @middleware.expects(:provisioner_configured?).returns(false)
+      @env[:vm].config.vm.expects(:provision).once
+      @middleware.call(@env)
+    end
+  end
+end