engineyard-local 0.2.1

data/install/osx/scripts/log.sh

@@ -0,0 +1,3 @@
+function log {
+  syslog -s -l notice "ey-local: $1"
+}

data/install/osx/scripts/postinstall

@@ -0,0 +1,57 @@
+#!/bin/bash
+
+# pull in our logging
+source log.sh
+
+# the assumed install directory for the package. This should be provided
+# as a setting from the ruby project by including a settings text file
+# in the installation package
+install_dir="/tmp/engineyard-local-installer"
+
+# TODO take the set and loop over it to run the install for each
+# logged in user
+current_user=`users | tail -1`
+
+# it would be nice to tie the directory to some variable
+# determined by the installer
+gems=`ls $install_dir/*.gem | xargs`
+
+# the name of the base box to be created, again would be nice
+# to include an installer file with these settings
+box_name="ey-gentoo-rack"
+
+# run the current command with a login shell as the current logged in user
+function as_current_user {
+  su $current_user -l -c "$1"
+}
+
+# run the post install scripts as the logged in user
+# --login is required to make sure that rvm is available when
+# installed and added to .bash_profile
+#
+# If they aren't though RVM starts into an infinite
+# loop because while the binary is present the scripts
+# directory isn't available in $HOME which may be /var/root
+# if run as `sudo -u $current_user`. That is, it thinks
+# there's no user install and then attempts to find the
+# root install despite the fact that its running the user install
+# script. After not finding one it proceeds to
+# execute the same command again and again.
+as_current_user "./rvm_install.sh $gems"
+
+# if rvm_install fails install to the system gems
+if [[ $? -gt 0 ]]; then
+  log "Installing gems to system ruby ..."
+  sudo gem install $gems
+fi
+
+log "Gem install complete"
+as_current_user "ey-local box list | grep $box_name"
+
+# install the packaged box for use with ey-local up
+if [[ $? -gt 0 ]]; then
+  log "Installing default box $box_name ..."
+  as_current_user "ey-local box add $box_name $install_dir/package.box"
+else
+  log "$box_name already installed ..."
+fi

data/install/osx/scripts/rvm_install.sh

@@ -0,0 +1,34 @@
+# if rvm is not installed exit with an error to signal
+# parent script that it needs to take action accordingly
+if [[ ! `which rvm` ]]; then
+  exit 1;
+fi
+
+# pull in our syslog loggerGH
+source log.sh
+
+# rvm has a habit of making its output nigh unparsable.
+# Here we have to strip the possible default ruby notation
+# of `=>` incase it's used so that our results are consistent
+# and can be run through awk to pull out the ruby
+#
+# possible `rvm list` output handled here:
+# => ruby-version-patch
+# ruby-version-patch
+default_ruby=`rvm list default | sed 's/=>/  /' | grep '^   ' | awk '{print \$1}'`
+current_ruby=`rvm current`
+
+# if the user has a default or current ruby install to one or the other
+# otherwise we can't know where it should be installed for rvm
+if [[ $default_ruby ]]; then
+  log "Installing gems to the default ruby: $default_ruby@global ..."
+  rvm use $default_ruby@global
+  gem install $@ --no-ri --no-rdoc
+elif [[ $current_ruby ]]; then
+  log "Installing gems to the current ruby: $current_ruby@global ..."
+  rvm use $current_ruby@global
+  gem install $@ --no-ri --no-rdoc
+else
+  log "No rvm default or current ruby detected ..."
+  exit 1
+fi

data/lib/engineyard-local.rb

@@ -0,0 +1,42 @@
+require "vagrant"
+require "pathname"
+require "yaml"
+
+# TODO settings object/management will be needed shortly
+module Engineyard
+  module Local
+    def self.project_root
+      @project_root ||= Pathname.new(File.expand_path('../../', __FILE__))
+    end
+
+    def self.project_file(path)
+      self.project_root + path
+    end
+
+    def self.config
+      @config ||= load_config_yaml("settings.yml")
+    end
+
+    # default to en until something more inteligent is required
+    # NOTE all locale information is contained in a single yaml
+    #      file in anticipation of relatively minimal use
+    def self.locales
+      @locales ||= load_config_yaml("locales/en.yml")
+    end
+
+    def self.load_config_yaml(config_rel_path)
+      yaml_file = File.expand_path("config/#{config_rel_path}", self.project_root)
+      YAML.load_file(yaml_file)
+    end
+  end
+end
+
+require "engineyard-local/virtualbox"
+require "engineyard-local/middleware/helpers"
+require "engineyard-local/middleware"
+require "engineyard-local/ui"
+require "engineyard-local/version"
+require "engineyard-local/command"
+require "engineyard-local/errors"
+
+I18n.load_path << Engineyard::Local.project_file("config/locales/en.yml")

data/lib/engineyard-local/command.rb

@@ -0,0 +1,65 @@
+module Engineyard
+  module Local
+    module Command
+      def self.all
+        Engineyard::Local.locales[:commands].keys.map { |cmd| cmd.to_s }
+      end
+
+      def self.passthrough
+        Engineyard::Local.config[:commands][:passthrough]
+      end
+
+      def self.dispatch(args)
+        Group.env = env = vagrant_env(args)
+
+        # if the flags need to be sent through on the command, avoid Thor
+        # otherwise start up Thor command line handling. Otherwise notify wrapper
+        # that nothing was dispatched.
+        if args.include?("-v") || args.include?("--version")
+          env.ui.info Engineyard::Local::VERSION, :prefix => false
+        elsif passthrough.include?(args.first)
+          cmd = Group.new(args, [], {})
+          cmd.send(args.first.to_sym, *args[1, args.length])
+        elsif all.include?(args.first) || args.length == 0
+          Group.start(args)
+        else
+          vagrant_env(args).cli(args)
+        end
+      rescue Vagrant::Errors::VagrantError => e
+        # TODO move to Vagrant Environment ui error
+        env.ui.error e.message if e.message
+        exit e.status_code if e.respond_to?(:status_code)
+        exit 999
+      end
+
+      def self.vagrant_env(args)
+        opts = {}
+
+        # setup the vagrant env properly for the commands to run
+        if args.include?("--no-color") || !$stdout.tty? || !Vagrant::Util::Platform.terminal_supports_colors?
+          # Delete the argument from the list so that it doesn't cause any
+          # invalid arguments down the road.
+          args.delete("--no-color")
+          opts[:ui_class] = UI::Basic
+        else
+          opts[:ui_class] = UI::Colored
+        end
+
+        new_env = Vagrant::Environment.new(opts)
+        new_env.load!
+        new_env
+      end
+    end
+  end
+end
+
+require "thor"
+# TODO autoload
+require "engineyard-local/command/helpers"
+require "engineyard-local/command/base"
+require "engineyard-local/command/group"
+require "engineyard-local/command/vagrant_action"
+require "engineyard-local/command/exec"
+require "engineyard-local/command/list"
+require "engineyard-local/command/rails"
+require "engineyard-local/command/up"

data/lib/engineyard-local/command/base.rb

@@ -0,0 +1,15 @@
+module Engineyard
+  module Local
+    module Command
+      class Base < Vagrant::Command::Base
+        include Command::Helpers
+
+        attr_reader :env, :options
+
+        def initialize(env, options)
+          @env, @options = env, options
+        end
+      end
+    end
+  end
+end

data/lib/engineyard-local/command/exec.rb

@@ -0,0 +1,11 @@
+module Engineyard
+  module Local
+    module Command
+      class Exec < Base
+        def exec(command_args)
+          run(Middleware::Exec, "eylocal.exec.command_args" => command_args)
+        end
+      end
+    end
+  end
+end

data/lib/engineyard-local/command/group.rb

@@ -0,0 +1,86 @@
+module Engineyard
+  module Local
+    module Command
+      # TODO move to purely vagrant command based setup
+      class Group < Thor
+        # TODO this class level env crap will go away once
+        #      these commands are moved out of thor to Vagrant commands
+        def self.env=(env)
+          @@env = env
+        end
+
+        no_tasks do
+          def env
+            @@env
+          end
+        end
+
+        # NOTE this is generally a bad idea as it might break between Vagrant versions
+        # the alternate is to monkey with the output (we're attempting to own the ux)
+        # from Thor where ey-local remains a Vagrant plugin. Either way the library
+        # is reaching into deps and using their internals, Vagrant is preferred here
+        # because the author has more experience with said internals
+        # TODO clean up the vagrant command environment init
+        def initialize(*args)
+          super
+        end
+
+        def self.command_info
+          Local.locales[:commands]
+        end
+
+        # register the command group eylocal
+        # register(*command_info[:eylocal])
+
+        # make sure rails is installed, run rails commands in the guest project share
+        method_option "version", :type => :string, :default => nil
+        desc(*command_info[:rails])
+        def rails(*args)
+          Command::Rails.new(env, options).exec(*args)
+        end
+
+        desc(*command_info[:exec])
+        def exec(*args)
+          Command::Exec.new(env, options).exec(args)
+        end
+
+        # streamlining of Vagrant up
+        method_option "no-bundle", :type => :boolean, :default => nil
+        method_option "no-db-setup", :type => :boolean, :default => nil
+        method_option "silent", :type => :boolean, :default => nil
+        desc(*command_info[:up])
+        def up(*args)
+          Command::Up.new(env, options).exec(*args)
+        end
+
+        method_option "environment", :type => :string, :default => "development"
+        method_option "lines", :type => :numeric, :default => 100
+        desc(*command_info[:log])
+        def log(*args)
+          cmd_args = ["tail -#{options["lines"]} log/#{options["environment"]}.log"]
+          Command::Exec.new(env, options).exec(cmd_args)
+        end
+
+        method_option "format", :type => :string, :default => "short"
+        desc(*command_info[:list])
+        def list
+          if options["format"] && !["short", "full"].include?(options["format"])
+            help("list")
+          else
+            Command::List.new(env, options).exec(options)
+          end
+        end
+
+        desc(*command_info[:start])
+        def start
+          Command::VagrantAction.new(env, options).exec(:resume)
+        end
+
+        desc(*command_info[:stop])
+        def stop
+          Command::VagrantAction.new(env, options).exec(:suspend)
+        end
+      end
+    end
+  end
+end

data/lib/engineyard-local/command/helpers.rb

@@ -0,0 +1,23 @@
+module Engineyard
+  module Local
+    module Command
+      module Helpers
+        def run(middleware, opts={}, &block)
+          with_target_vms do |vm|
+            opts = merge_run_options(vm, opts)
+            vm.env.action_runner.run(middleware, opts)
+          end
+        end
+
+        # TODO borrowed entirely from vagrant, running outside it's command
+        # structure is causing issues that need remedy
+        def merge_run_options(vm, opts={})
+          {
+            :vm => vm,
+            :ui => vm.env.ui.dup
+          }.merge(opts || {})
+        end
+      end
+    end
+  end
+end

data/lib/engineyard-local/command/list.rb

@@ -0,0 +1,29 @@
+module Engineyard
+  module Local
+    module Command
+      class List < Base
+        def exec(options)
+          Virtualbox.uuid_map.each do |name, uuid|
+            project_root = Virtualbox.extra_data(uuid, Local.config[:managed_vm_key])
+
+            if project_root
+              # move the uuid and project root to the front of the output
+              # for easier cutting since it's less likely to have spaces
+              env.ui.info format(uuid, project_root, name), :prefix => false
+            end
+          end
+        end
+
+        def format(uuid, project_root, name)
+          result = "#{uuid} #{project_root}"
+
+          if @options[:format] == "full"
+            "#{result} #{name}"
+          else
+            result
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Engineyard
+  module Local
+    module Command
+      class Rails < Base
+        def exec(*command_args)
+          scoped_options = options
+
+          stack = Vagrant::Action::Builder.new do
+            use Middleware::Rails::Install, "eylocal.rails.version" => scoped_options["version"]
+            use Middleware::Rails::Command, "eylocal.rails.command_args" => command_args
+          end
+
+          run stack
+        end
+      end
+    end
+  end
+end
+

data/lib/engineyard-local/command/up.rb

@@ -0,0 +1,87 @@
+module Engineyard
+  module Local
+    module Command
+      class Up < Base
+        def box_defaults
+          Local.config[:box_defaults]
+        end
+
+        def box_exists?(name)
+          env.boxes.map { |box| box.name }.include?(name)
+        end
+
+        # convention based streamlining of Vagrant's up
+        def exec(name=box_defaults[:name], uri=box_uri)
+          if box_exists?(name)
+            env.ui.warn(I18n.t("eylocal.up.box_exists", :name => name))
+          else
+            env.cli("box", "add", name, uri)
+          end
+
+          # if a Vagrant file does NOT exist create one
+          if env.root_path.nil?
+            env.cli("init", name)
+          end
+
+          # resets vagrant root path so that it can detect the
+          # newly initialized Vagrantfile, and the newly added box
+          # TODO submit alternate reset of root path to Vagrant
+          env.send(:remove_instance_variable, :@root_path)
+          env.load_config!
+          env.boxes.reload!
+
+          env.ui.info(I18n.t("eylocal.up.root_path", :root_path => env.root_path))
+          if File.expand_path(env.root_path) != File.expand_path(Dir.pwd)
+            env.ui.info(I18n.t("eylocal.up.root_path_instructions", :root_path => env.root_path, :pwd => Dir.pwd))
+          end
+
+          # don't build a box if its already built
+          with_target_vms do |vm|
+            if vm.created?
+              env.ui.info I18n.t("vagrant.commands.up.vm_created")
+            else
+              up = Vagrant.actions.get(:up)
+
+              # insert the tag before the box is in a state where it can't be saved eg running
+              up.insert_before(Vagrant::Action::VM::CheckGuestAdditions, Middleware::Tag)
+              up.insert_before(Vagrant::Action::VM::CheckGuestAdditions, Middleware::Network, @options)
+
+              opts = merge_run_options(vm)
+              vm.env.action_runner.run(up, opts)
+            end
+          end
+
+          # finish the box setup
+          run setup_stack(options)
+        end
+
+        private
+
+        # prefer the the base box included with the installer if it exists
+        # otherwise use the default downloadable box
+        def box_uri
+          default_path = Engineyard::Local.project_root + "default.box"
+
+          if File.exists?(default_path)
+            # to_s required here as the path will be scanned for http
+            # by Vagrant
+            default_path.to_s
+          else
+            box_defaults[:uri]
+          end
+        end
+
+        # install the application bundle and create/migrate the database
+        # TODO check for the database.yml and fail gracefully
+        def setup_stack(options)
+          Vagrant::Action::Builder.new do
+            use Middleware::DNA unless options["no-dna"]
+            use Middleware::Chef unless options["no-chef"]
+            use Middleware::Bundle unless options["no-bundle"]
+            use Middleware::Rails::DB unless options["no-db-setup"]
+          end
+        end
+      end
+    end
+  end
+end