cuken 0.1.13 → 0.1.15

data/lib/cuken/api/rvm.rb

@@ -1,501 +1,47 @@
+require 'rvm'
+require 'cuken/api/common'
+require 'cuken/api/rvm/common'
+require 'cuken/api/rvm/gemsets'
+
 module ::Cuken
   module Api
     module Rvm
 
-      class RvmrcProcessor
-
-        attr_writer :gemspecs_to_install
-
-        def initialize(path)
-          @root_path = ::File.directory?(path) ? path : File.dirname(path)
-           rvmrc_read(path)
-        end
-
-        # read the .rvmrc file contents into @rvmrc
-        def rvmrc_read(path)
-          fn = ::File.directory?(path) ? path + '/.rvmrc' : path
-          @rvmrc = ::File.new(fn).read
-          return true if @rvmrc.size > 0
-        end
-
-        # return the .rvmrc file contents
-        def rvmrc
-          @rvmrc
-        end
-
-        # return ruby name parsed from .rvmrc file contents
-        def rvmrc_ruby_name
-          extract_rubie(rvmrc)
-        end
-
-        # return gemset name parsed from .rvmrc file contents
-        def rvmrc_gemset_name
-          extract_gemset(rvmrc)
-        end
-
-        # return concatenated string of rvmrc_ruby@rvmrc_gemset
-        def rvmrc_ruby_gemset(rvmrc)
-          "#{extract_rubie(rvmrc)}@#{extract_gemset(rvmrc)}"
-        end
-
-        # return an array of .rvmrc file paths found beneath a root folder
-        def find_rvmrc_files(rvmrc_root)
-          Dir.glob(rvmrc_root + '/**' + '/.rvmrc')
-        end
-
-        # return an arry of paths containing .rvmrc files
-        def find_rvmrc_paths(rvmrc_root)
-          root = File.directory?(rvmrc_root) ?  rvmrc_root : File.dirname(rvmrc_root)
-          dirs = []
-          find_rvmrc_files(root).each do |path|
-            dirs << File.dirname(File.expand_path(path)) if File.file?(path)
-          end
-          dirs
-        end
-
-        #return an array of *.gems file paths found beneath a root folder
-        def find_gems_files(rvmrc_root)
-          Dir.glob(rvmrc_root + '/**' + '/*.gems')
-        end
-
-        # returns rubies and gemsets from .rvmrc files glob'ed below
-        # a root folder.
-        def all_rubies_gemsets(root_path=@root_path)
-          @all_rubies_gemsets = Hash.new([])
-          arry=find_rvmrc_paths(root_path)
-          arry.each do |dir|
-            Dir.glob(dir + '/*.gems').each do |fn|
-              gsn     = File.basename(fn,'.gems').to_s
-              rvmrc_read(dir + '/.rvmrc')
-              rube    = rvmrc_ruby_name
-              egsn    = rvmrc_gemset_name
-              @all_rubies_gemsets[rube] = [] unless @all_rubies_gemsets.key? rube
-              if gsn == egsn
-                @all_rubies_gemsets[rube] << {:ruby_alias => "cuken_#{rube}",:gemset_alias => "cuken_#{gsn}", :gemset_name => gsn, :gemset_path => fn}
-              end
-            end
-          end
-          @all_rubies_gemsets
-         end
+      extend ::RVM
+      include ::Cuken::Api::Rvm::Common
+      include ::Cuken::Api::Aruba::Api
 
-        # returns hash of all gemsets, per-Ruby, in all .rvmrc files beneath a root folder
-        def all_gemsets(root_path=@root_path)
-          default = Hash.new{|hsh,ky| hsh[ky] = {:ruby_alias => "cuken_#{ky}"}}
-          @all_rubies_gemsets ||= all_rubies_gemsets(root_path)
-          @all_gemsets = @all_rubies_gemsets.inject(default){|h,(k,v)| h[k]; h[k][:gemsets]=v; h }
-        end
-
-        # returns array of all rubies in all .rvmrc files beneath a root folder
-        def all_rubies(root_path=@root_path)
-          @all_rubies_gemsets ||= all_rubies_gemsets(root_path)
-          @all_rubies = @all_rubies_gemsets.keys
-        end
+      class RvmHelper
 
-        # yield a block in the environment of each in the installed rubies,
-        # and return current Ruby string even if the given block raises
-        def each_ruby
-          begin
-            all_rubies(@root_path).each do |rubie|
-              RVM.use(rubie)
-              yield rubie
-            end
-          rescue
-          ensure
-            RVM.reset_current!
-          end
-        end
+        attr_reader :environment
 
-        # create gemsets parsed from all .rvmrc files beneath a root folder
-        def create_gemsets
-          each_ruby do |rubie|
-            all_gemsets(@root_path)[rubie][:gemsets].each do |hsh|
-              ::RVM.gemset.create([hsh[:gemset_name]])
-            end
-          end
+        def init
+          RVM::Environment
         end
 
-        # Return array of [gem_name, gem_version] to be installed into all
-        # gemsets found in .rvmrc files. Default is Bundler versio 1.0.10
-        def gemspecs_to_install
-          @gemspecs_to_install ||= [['bundler', '1.0.10']]
+        def current
+          @current = RVM.current
         end
 
-      # Install @gemspecs_to_install contents using rubies and gemsets
-      # found in .rvmrc files.
-      def gems_install
-        create_gemsets
-        each_ruby do |rubie|
-          gemspecs_to_install.each { |spec| install_gem(rubie, spec) }
+        def environment_name
+          current.environment_name
         end
-      end
-
-      # return the options string for Ruby's `gem install...` CLI
-      def gem_install_options
-        @gem_install_options ||= ['no_ri', 'no_rdoc']
-        "--" + @gem_install_options.join(' --')
-      end
 
-      # install given gem into all ruby+gemsets parsed from .rvmrc files beneath a root folder
-      def install_gem(rubie, spec)
-        gem, version = spec
-        all_gemsets.each do |rubie, hsh|
-          hsh[:gemsets].each do |h|
-            if gem_available?(spec)
-              puts "info: Gem #{gem}-#{version} already installed in #{rvm_current_name}."
-            else
-              puts "info: Installing gem #{gem}-#{version} in #{rvm_current_name}..."
-              RVM.gemset.use(h[:gemset_alias])
-              RVM.run("rvm --create use #{h[:gemset_alias]}; gem install #{gem} -v#{version} #{gem_install_options}")
-            end
-          end
+        def gemset
+          current.gemset
         end
-      end
-
-      # return the parsed .rvmrc info for the current ruby
-      def current_ruby_info(rubie)
-        @all_rubies_gemsets ||= all_rubies_gemsets
-        @all_rubies_gemsets[rubie]
-      end
 
-      def rvm_path
-        pn = Pathname.new(File.expand_path(ENV['rvm_path'] || '~/.rvm'))
-        pn.exist? ? pn : raise(RuntimeError, "Could not find RVM's .rvm folder (#{pn})", caller)
-      end
-      # Does not install existing RVM rubies that are listed in the .rvmrc files
-      # raise an error if RVM's install root does not exist
-      def setup_rubies
-        rvm_loaded? ? true : raise(RuntimeError, "RVM library not loaded.", caller)
-        @all_rubies_gemsets ||= all_rubies_gemsets(@root_path)
-        @all_rubies_gemsets.keys.each do |rubie|
-          if RVM.list_strings.include?(rubie)
-            puts "info: Rubie #{rubie} already installed."
-          else
-            with_rvm_environment_vars do
-              install_rubie(rubie)
-            end
-          end
-          RVM.alias_create(current_ruby_info(rubie)[0][:ruby_alias], "#{rubie}") unless rubie == current_ruby_info(rubie)[0][:ruby_alias]
+        def environment(gemset, options={})
+          @environemnt = self.new(gemset, options)
+          yield @environemnt if block_given?
+          @environemnt
         end
       end
 
-        private
-          def extract_rubie(rvmrc)
-            rvmrc[/ruby_id=\"(.*)\"/, 1]
-          end
-          def extract_gemset(rvmrc)
-            rvmrc[/gemset_id=\"(.*)\"/, 1]
-          end
-          def gem_available?(spec)
-            gem, version = spec
-            RVM.ruby_eval("require 'rubygems' ; print Gem.available?('#{gem}','#{version}')").stdout == 'true'
-          end
-          def rvm_current_name
-            RVM.current.expanded_name
-          end
-
-          def rvm_loaded?
-            @rvm_setup = defined?(RVM) ? true : false
-            return(true) if @rvm_setup
-            rvm_lib_path = rvm_path + "lib" rescue return
-            $LOAD_PATH.unshift(rvm_lib_path.to_s) unless $LOAD_PATH.include?(rvm_lib_path.to_s)
-            require 'rvm'
-            @rvm_setup = defined?(RVM) ? true : false
-          end
-
-          def install_rubie(rubie)
-            std_msg = "info: Rubie #{rubie} installed."
-            err_msg  = "Failed #{rubie} install! Check RVM logs here: #{RVM.path}/log/#{rubie}"
-            puts "info: Rubie #{rubie} installation inprogress. This couldtake awhile..."
-            RVM.install(rubie, rvm_install_options) ? puts(std_msg) : abort(err_msg)
-          end
-
-          def rvm_install_options
-            { }
-          end
-
-          def with_rvm_environment_vars
-            my_vars = rvm_environment_vars
-            current_vars = my_vars.inject({}) { |cvars,kv| k,v = kv ; cvars[k]= ENV[k] ; cvars }
-            set_environment_vars(my_vars)
-            yield
-            ensure
-            set_environment_vars(current_vars)
-          end
-
-          def set_environment_vars(vars)
-            vars.each { |k,v| ENV[k] = v }
-          end
-
-          def rvm_environment_vars
-             if rvm_for_macports?
-               {'CC' => '/usr/bin/gcc-4.2',
-                'CFLAGS' => '-O2 -arch x86_64',
-                'LDFLAGS' => '-L/opt/local/lib -arch x86_64',
-                'CPPFLAGS' => '-I/opt/local/include'}
-             else
-               {}
-             end
-           end
-
-           def rvm_for_macports?
-             `uname`.strip == 'Darwin' && `which port`.present?
-           end
-
-      end # class RvmrcProcessor
-
-      module_function
-       class << self
-         attr_accessor :rvm_install_rubies, :rvm_install_gem_specs,
-           :rvm_gem_install_options
-       end
-
-      def rvmrc(path)
-         @rvmrc ||= RvmrcProcessor.new(path)
-      end
-
-      def rvm_current_name
-        RVM.current.expanded_name
-      end
-
-      def rvm_gem_install_options
-        @rvm_gem_install_options ||= ['no_ri', 'no_rdoc']
-        "--" + @rvm_gem_install_options.join(' --')
-      end
-
-      def rvm_install_rubies
-        @rvm_install_rubies ||= []
+      def rvm
+        @rvm ||= RvmHelper.new
       end
-
-      def rvm_install_gemspecs
-        @rvm_install_gemspecs ||= [['bundler', '1.0.10']]
-      end
-
-      def rvm_create_gemsets
-        @rvm_create_gemsets ||= []
-      end
-
-      def rvm_requested_gemset(gemset)
-        @rvm_requested_gemset = gemset
-      end
-
-      def rvm_requested_gemset
-        @rvm_requested_gemset ||='vagrant'
-      end
-      #wip
-      def rvm_path
-        pn = Pathname.new(File.expand_path(ENV['rvm_path'] || '~/.rvm'))
-        pn.exist? ? pn : raise(RuntimeError, "Could not find RVM's .rvm folder (#{pn})", caller)
-      end
-
-      def rvm_local_install?
-        rvm_path.dirname.realpath.directory?
-      end
-      # done
-      def rvm_loaded?
-        _rvm_load
-      end
-
-      def rvm_gemset_paths(root_path='/usr/src/cuken')
-        rpn = Pathname(root_path)
-        rvmrc_dirs = []
-        Dir.glob((rpn + '**' + '.rvmrc').to_s).each do |d|
-          dn = File.dirname(d)
-          rvmrc_dirs << dn if File.directory?(dn)
-        end
-        rvmrc_dirs
-      end
-
-      # done
-      def rvmrc_rubies_gemsets(root_path='/usr/src/cuken')
-        @rvmrc_rubies_gemsets = Hash.new([])
-        arry=rvm_gemset_paths(root_path)
-        arry.each do |dir|
-          Dir.glob(dir + '/*.gems').each do |fn|
-            gsn     = File.basename(fn,'.gems').to_s
-            rvmrc   = File.new(File.dirname(fn) + '/.rvmrc').read
-            rube    = rvmrc_extract_ruby(rvmrc)
-            egsn    = rvmrc_extract_gemset(rvmrc)
-            @rvmrc_rubies_gemsets[rube] = [] unless @rvmrc_rubies_gemsets.key? rube
-            @rvmrc_rubies_gemsets[rube] << gsn if gsn == egsn
-          end
-        end
-        @rvmrc_rubies_gemsets
-       end
-      # done
-      def rvmrc_rubies
-        @rvmrc_rubies ||= _rvmrc_rubies #.keys.map{ |rubie| "#{rubie}@#{rvm_requested_gemset}" }
-      end
-      #wip
-      def rvm_rubies_setup(root_path='/usr/src/cuken')
-        rvm_loaded? ? true : raise(RuntimeError, "RVM library not loaded.", caller)
-        @rvmrc_rubies_gemsets ? true : rvmrc_rubies_gemsets(root_path)
-        @rvmrc_rubies_gemsets.keys.each do |rubie|
-          if RVM.list_strings.include?(rubie)
-            puts "info: Rubie #{rubie} already installed."
-          else
-            with_rvm_environment_vars do
-              _rvm_install_rubie(rubie)
-            end
-          end
-          RVM.alias_create(rvmrc_rubies[rubie][:alias], "#{rubie}@#{rvm_requested_gemset}") unless rubie == rvmrc_rubies[rubie][:alias]
-        end
-      end
-      #done
-      def rvm_current_rubie_info
-        rvmrc_rubies[_rvm_current_rubie_name]
-      end
-
-      # Install @rvm_install_gemspecs gemspec using rubies and gemsets
-      # found in .rvmrc files.
-      # done
-      def rvmrc_gems_install(root_path)
-        @rvmrc_root_path = root_path
-        _rvmrc_create_gemsets
-        _each_rvmrc_rubie do |rubie|
-          rvm_install_gemspecs.each { |spec| _rvmrc_install_gem(rubie, spec) }
-        end
-      end
-
-      def rvmrc_gemsets_install(root_path)
-        @rvmrc_root_path = root_path
-        _each_rvmrc_rubie do |rubie|
-          rvm_install_gemspecs.each { |spec| _rvmrc_install_gem(rubie, spec) }
-        end
-      end
-
-      protected
-      #done
-      def _rvm_load
-        @rvm_setup = false
-        rvm_lib_path = rvm_path + "lib" rescue return
-        $LOAD_PATH.unshift(rvm_lib_path.to_s) unless $LOAD_PATH.include?(rvm_lib_path.to_s)
-        require 'rvm'
-        @rvm_setup = defined?(RVM) ? true : false
-      end
-      module_function :_rvm_load
-      #done
-      def _rvm_install_rubie(rubie)
-        std_msg = "info: Rubie #{rubie} installed."
-        err_msg  = "Failed #{rubie} install! Check RVM logs here: #{RVM.path}/log/#{rubie}"
-        puts "info: Rubie #{rubie} installation inprogress. This couldtake awhile..."
-        RVM.install(rubie, rvm_install_options) ? puts(std_msg) : abort(err_msg)
-      end
-      module_function :_rvm_install_rubie
-
-      #done
-      def rvmrc_extract_ruby_gemset(rvmrc)
-        "#{rvmrc_extract_ruby(rvmrc)}@#{rvmrc_extract_gemset(rvmrc)}"
-      end
-      module_function :rvmrc_extract_ruby_gemset
-      #done
-      def rvmrc_extract_ruby(rvmrc)
-        rvmrc[/ruby_id=\"(.*)\"/, 1]
-      end
-      module_function :rvmrc_extract_ruby
-      #done
-      def rvmrc_extract_gemset(rvmrc)
-        rvmrc[/gemset_id=\"(.*)\"/, 1]
-      end
-      module_function :rvmrc_extract_gemset
-      #done
-      def _rvmrc_rubies
-        default = Hash.new{|hsh,ky| hsh[ky] = {:alias => "cuken-#{ky}"}}
-        @rvmrc_rubies_gemsets ||= rvmrc_rubies_gemsets(@rvmrc_root_path)
-        @rvmrc_rubies = @rvmrc_rubies_gemsets.keys.inject(default){|h,(k,v)| h[k]; h }
-      end
-      module_function :_rvmrc_rubies
-      #done
-      def _rvmrc_gemsets
-        default = Hash.new{|hsh,ky| hsh[ky] = {:alias => "cuken-#{ky}"}}
-        @rvmrc_rubies_gemsets ||= rvmrc_rubies_gemsets(@rvmrc_root_path)
-        @rvmrc_gemsets = @rvmrc_rubies_gemsets.inject(default){|h,(k,v)| h[k]; h[k][:gemsets]=v; h }
-      end
-      module_function :_rvmrc_gemsets
-      # done
-      def _each_rvmrc_rubie
-        _rvmrc_rubies.each do |ary|
-          RVM.use(ary[0])
-          yield ary[0]
-        end
-      ensure
-        RVM.reset_current!
-      end
-      module_function :_each_rvmrc_rubie
-      # done
-      def _rvmrc_create_gemsets
-        _rvmrc_gemsets.each do |hsh|
-          RVM.use hsh[0]
-          hsh[1][:gemsets].each do |gmst|
-            # TODO: Post refactor
-            #RVM.gemset.create([gmst])
-          end
-        end
-      end
-      module_function :_rvmrc_create_gemsets
-      #done
-      def _rvmrc_install_gem(rubie, spec)
-        gem, version = spec
-        _rvmrc_gemsets.each do |hsh|
-          rubie = hsh[0]
-          hsh[1][:gemsets].each do |gmst|
-            #RVM.gemset.create([gmst])
-            RVM.gemset.use(gmst)
-            if _rvm_gem_available?(spec)
-              puts "info: Gem #{gem}-#{version} already installed in #{rvm_current_name}."
-            else
-              puts "info: Installing gem #{gem}-#{version} in #{rvm_current_name}..."
-              RVM.run("rvm --create use #{rubie}@#{gmst}; gem install #{gem} -v#{version} #{rvm_gem_install_options}")
-            end
-          end
-        end
-      end
-      module_function :_rvmrc_install_gem
-
-      # done
-      def set_environment_vars(vars)
-        vars.each { |k,v| ENV[k] = v }
-      end
-      module_function :set_environment_vars
-      #done
-      def with_rvm_environment_vars
-        my_vars = rvm_environment_vars
-        puts my_vars
-        current_vars = my_vars.inject({}) { |cvars,kv| k,v = kv ; cvars[k]= ENV[k] ; cvars }
-        puts current_vars
-        set_environment_vars(my_vars)
-        yield
-        ensure
-        set_environment_vars(current_vars)
-      end
-      module_function :with_rvm_environment_vars
-      #done
-      def rvm_environment_vars
-         if rvm_for_macports?
-           {'CC' => '/usr/bin/gcc-4.2',
-            'CFLAGS' => '-O2 -arch x86_64',
-            'LDFLAGS' => '-L/opt/local/lib -arch x86_64',
-            'CPPFLAGS' => '-I/opt/local/include'}
-         else
-           {}
-         end
-       end
-       module_function :rvm_environment_vars
-       #done
-       def rvm_for_macports?
-         `uname`.strip == 'Darwin' && `which port`.present?
-       end
-       module_function :rvm_for_macports?
-       # done
-       def rvm_install_options
-         { }
-       end
-       module_function :rvm_install_options
-      #done
-      def _rvm_gem_available?(spec)
-        gem, version = spec
-        RVM.ruby_eval("require 'rubygems' ; print Gem.available?('#{gem}','#{version}')").stdout == 'true'
-      end
-      module_function :_rvm_gem_available?
     end
   end
 end
+

data/lib/cuken/api/ssh.rb

@@ -1,4 +1,4 @@
-require 'aruba/api' unless defined? Aruba::Api
+#require 'aruba/api' unless defined? Aruba::Api
 require 'cuken/api/ssh-forever'  unless defined? SecureShellForever
 
 module Cuken
@@ -6,12 +6,48 @@ module Cuken
     module Ssh
 
       def ssh_init_password_less
-        @ssh_forever_options ||= ssh_forever_default_options
-        cmd = ssh_forever(@ssh_forever_options)
-        run_simple(unescape(cmd))
+        @ssh_options ||= ssh_default_options
+        cmd = ssh_cmd(@ssh_options)
+        announce_or_puts(unescape(cmd))
       end
 
       def ssh_init_password_less_batch(table=nil)
+        if table == :default
+          return @ssh_options = ssh_default_options
+        elsif table.nil?
+          return @ssh_options ||={}
+        end
+        @ssh_options ||={}
+        table.hashes.each do |hash|
+          hsh = parse_ssh_options(hash)
+          cmd = ssh_cmd(hsh)
+          ssh_run(cmd)
+        end
+      end
+
+      def ssh_init_password_less_interactive(table=nil)
+        if table == :default
+          return @ssh_options = ssh_default_options
+        elsif table.nil?
+          return @ssh_options ||={}
+        end
+        @ssh_options ||={}
+        table.hashes.each do |hash|
+          hsh = parse_ssh_options(hash)
+          cmd = ssh_cmd(hsh)
+          ssh_login_interactive(cmd)
+        end
+      end
+
+      def ssh_run(cmd)
+        run_simple(unescape(cmd))
+      end
+
+      def ssh_login_interactive(cmd)
+        run_interactive(unescape(cmd))
+      end
+
+      def ssh_forever_init_password_less_batch(table=nil)
         if table == :default
           return @ssh_forever_options = ssh_forever_default_options
         elsif table.nil?
@@ -59,6 +95,26 @@ module Cuken
         "ssh-forever #{hsh[:user]}@#{hsh[:hostname]} -p #{hsh[:port]} -i ~/.ssh/id_rsa_cuken -n #{hsh[:name]} -b"
       end
 
+      def ssh_cmd(hsh)
+        if hsh[:alias]
+          #append_ssh_config unless existing_ssh_config?
+          login_command = "ssh #{hsh[:alias]} #{ssh_args(hsh)}"
+        else
+          login_command = "ssh #{hsh[:user]}@#{hsh[:hostname]}#{ssh_args(hsh)}"
+        end
+        login_command
+      end
+
+      def ssh_args(hsh)
+        [ ' ',
+          ("-i #{hsh[:identity_file]}" if hsh[:identity_file]),
+          ("-F #{hsh[:config_file]}" if hsh[:config_file]),
+          ("-p #{hsh[:port]}" if hsh[:port] =~ /^\d+$/),
+          (hsh[:stricthostkeychecking] == 'yes' ? "-o stricthostkeychecking=yes" : "-o stricthostkeychecking=no"),
+          (hsh[:debug] ? "-vvv" : "-q")
+        ].compact.join(' ')
+      end
+
       def parse_ssh_forever_options(hsh)
         new_hsh = hsh.inject({}) { |h, (k, v)| h[k.intern] = v; h }
         ssh_forever_default_options.merge(new_hsh).inject({}) do |h, (k, v)|
@@ -78,11 +134,36 @@ module Cuken
         end
       end
 
+      def parse_ssh_options(hsh)
+        new_hsh = hsh.inject({}) { |h, (k, v)| h[k.intern] = v; h }
+        ssh_default_options.merge(new_hsh).inject({}) do |h, (k, v)|
+          v=v.to_s
+          if v[/\:default/]
+            v = ssh_default_options[k.to_sym]
+            h[k]=v
+            next h
+          end
+          if v[/`(.*)`/]
+            cmd=v.gsub(/`/,'')
+            run_simple(unescape(cmd))
+            v = output_from(cmd).strip
+          end
+          h[k]=v
+          h
+        end
+      end
+
       def ssh_forever_default_options
         {:user => ssh_client_username, :hostname => ssh_client_hostname,
         :port => 22, :name => 'cuken', :identity_file => '~/.ssh/id_rsa_cuken',
         :auto => true, :intense => true, :quiet => true }
       end
+
+      def ssh_default_options
+        {:user => ssh_client_username, :hostname => ssh_client_hostname,
+        :port => 22, :identity_file => '~/.ssh/id_rsa',
+        :quiet => true }
+      end
     end
   end
 end

data/lib/cuken/api/vagrant/common.rb

@@ -20,7 +20,8 @@ module ::Cuken
       module Common
 
         def establish_vm_interactive_ssh(boxname)
-          cmd = vagrant.vm[boxname.to_sym].ssh.ssh_connect_command
+          name = vagrant.vm.key?(:primary) ? :primary  : boxname.to_sym
+          cmd = vagrant.vm[name].ssh.ssh_connect_command
           run_interactive(unescape(cmd))
         end
 
@@ -41,7 +42,7 @@ module ::Cuken
               end
             end
           else
-            in_current_dir do
+            in_dir do
               if expect_presence
                 load_vagrant_file(path)
               end
@@ -68,10 +69,12 @@ module ::Cuken
         def check_vm_state(name, state, expect_state = true )
           in_chef_root do
             if expect_state
+              # puts vagrant.status(name).inspect
               vagrant.vm[name.to_sym].vm.state.should == state
             else
-              vagrant.vm[name.to_sym].vm.state.should_not == state
-            end
+              puts vagrant.status(name).inspect
+              vagrant.status(name).include?(state).should be_false
+             end
           end
         end
 

data/lib/cuken/api/vagrant/v_m.rb

@@ -37,7 +37,7 @@ module ::Cuken
         end
 
         def vms
-          @vms = environment.instance_variable_get(:@vms)
+          @vms = environment.vms
         end
 
 #        def name
@@ -80,7 +80,7 @@ module ::Cuken
         end
 
         def state(name)
-          vm[name.to_sym].vm.state
+          vms[name.to_sym].vm ? vms[name.to_sym].vm.state : nil
         end
 
         def run_vagrant_cli(cmd, vm_name)