micro-cf-plugin 0.1.0.rc1

data/Rakefile

@@ -0,0 +1,38 @@
+require "rake"
+require "rspec/core/rake_task"
+
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require "micro-cf-plugin/version"
+
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec
+
+namespace :deploy do
+  def last_staging_sha
+    `git rev-parse latest-staging`.strip
+  end
+
+  def last_release_sha
+    `git rev-parse latest-release`.strip
+  end
+
+  def last_staging_ref_was_released?
+    last_staging_sha == last_release_sha
+  end
+
+  task :staging, :version do |_, args|
+    sh "gem bump --push #{"--version #{args.version}" if args.version}" if last_staging_ref_was_released?
+    sh "git tag -f latest-staging"
+    sh "git push origin :latest-staging"
+    sh "git push origin latest-staging"
+  end
+
+  task :gem do
+    sh "git fetch"
+    sh "git checkout #{last_staging_sha}"
+    sh "gem release --tag"
+    sh "git tag -f latest-release"
+    sh "git push origin :latest-release"
+    sh "git push origin latest-release"
+  end
+end

data/config/offline.conf

@@ -0,0 +1,2 @@
+no-resolv
+log-queries

data/config/paths.yml

@@ -0,0 +1,22 @@
+darwin:
+  vmrun:
+  - "/Applications/VMware Fusion.app/Contents/Library/"
+  - "/Applications/Fusion.app/Contents/Library/"
+  vmx:
+  - "~/Documents/Virtual Machines.localized/"
+  - "~/Documents/Virtual Machines/"
+  - "~/Desktop/"
+
+linux:
+  vmrun:
+  - "/usr/bin/"
+  vmx:
+  - "~/"
+
+windows:
+  vmrun:
+  - "c:\\Program Files (x86)\\"
+  - "c:\\Program Files\\"
+  vmx:
+  - "~\\Documents\\"
+  - "~\\Desktop\\"

data/config/refresh_ip.rb

@@ -0,0 +1,24 @@
+#!/var/vcap/bosh/bin/ruby
+require 'socket'
+
+A_ROOT_SERVER = '198.41.0.4'
+
+begin
+  retries ||= 0
+  route ||= A_ROOT_SERVER
+  orig, Socket.do_not_reverse_lookup = Socket.do_not_reverse_lookup, true
+  ip_address = UDPSocket.open do |s|
+    s.connect(route, 1); s.addr.last
+  end
+rescue Errno::ENETUNREACH
+# happens on boot when dhcp hasn't completed when we get here
+  sleep 3
+  retries += 1
+  retry if retries < 10
+ensure
+  Socket.do_not_reverse_lookup = orig
+end
+
+File.open("/tmp/ip.txt", 'w') do |file|
+  file.write(ip_address)
+end

data/lib/micro-cf-plugin/errors.rb

@@ -0,0 +1,4 @@
+module CFMicro
+  class MCFError < RuntimeError
+  end
+end

data/lib/micro-cf-plugin/help.rb

@@ -0,0 +1,4 @@
+require "mothership/help"
+
+Mothership::Help.groups(
+  [:micro, "Micro Cloud Foundry"])

data/lib/micro-cf-plugin/micro/micro.rb

@@ -0,0 +1,56 @@
+require 'find'
+require "micro-cf-plugin/errors"
+
+module CFMicro
+  def config_file(file)
+    File.expand_path("../../../../config/#{file}", __FILE__)
+  end
+
+  def escape_path(path)
+    path = File.expand_path(path)
+    if RUBY_PLATFORM =~ /mingw|mswin32|cygwin/
+      if path.include?(' ')
+        '"' + path + '"'
+      else
+        path
+      end
+    else
+      path.gsub(' ', '\ ')
+    end
+  end
+
+  def locate_file(file, directory, search_paths)
+    search_paths.each do |path|
+      expanded_path = File.expand_path(path)
+      next unless File.exists?(expanded_path)
+      Find.find(expanded_path) do |current|
+        if File.directory?(current) && current.include?(directory)
+          full_path = File.join(current, file)
+          return escape_path(full_path) if File.exists?(full_path)
+        end
+      end
+    end
+
+    false
+  end
+
+  def run_command(command, args=nil)
+    # TODO switch to using posix-spawn instead
+    result = %x{#{command} #{args} 2>&1}
+    if $?.exitstatus == 0
+      result.split(/\n/)
+    else
+      if block_given?
+        yield
+      else
+        raise CFMicro::MCFError, "failed to execute #{command} #{args}:\n#{result}"
+      end
+    end
+  end
+
+  module_function :config_file
+  module_function :escape_path
+  module_function :locate_file
+  module_function :run_command
+
+end

data/lib/micro-cf-plugin/micro/switcher/base.rb

@@ -0,0 +1,79 @@
+require "micro-cf-plugin/errors"
+
+module CFMicro::Switcher
+  class Base
+
+    def initialize(config)
+      @config = config
+
+      @vmrun = CFMicro::VMrun.new(config)
+    end
+
+    #wrapper methods
+    def vmx
+      @vmrun.vmx
+    end
+
+    def domain
+      @vmrun.domain
+    end
+
+    def ip
+      @vmrun.ip
+    end
+
+    def running?
+      @vmrun.running?
+    end
+
+    def start!
+      @vmrun.start!
+    end
+
+    def ready?
+      @vmrun.ready?
+    end
+
+    def offline?
+      @vmrun.offline?
+    end
+
+    def nat?
+      @config['online_connection_type'] ||= @vmrun.connection_type
+      @config["online_connection_type"] == "nat"
+    end
+
+    def reset_to_nat!
+      @vmrun.connection_type = 'nat'
+      @vmrun.reset
+    end
+
+    def set_host_dns!
+      @config['domain'] ||= @vmrun.domain
+      @config['ip'] ||= @vmrun.ip
+      set_nameserver(@config['domain'], @config['ip'])
+    end
+
+    def unset_host_dns!
+      @config['domain'] ||= @vmrun.domain
+      @config['ip'] ||= @vmrun.ip
+      unset_nameserver(@config['domain'], @config['ip'])
+    end
+
+    def offline!
+      if  @vmrun.offline?
+        raise CFMicro::MCFError, "Micro Cloud Foundry VM already in offline mode"
+      else
+        @vmrun.offline!
+      end
+    end
+
+    def online!
+      if @vmrun.offline?
+        @vmrun.online!
+      else
+        raise CFMirco::MCFError, "Micro Cloud Foundry already in online mode"
+      end
+    end
+  end
+end

data/lib/micro-cf-plugin/micro/switcher/darwin.rb

@@ -0,0 +1,21 @@
+require "micro-cf-plugin/errors"
+
+module CFMicro::Switcher
+
+  class Darwin < Base
+    def adminrun(command)
+      CFMicro.run_command("osascript", "-e 'do shell script \"#{command}\" with administrator privileges'")
+    end
+
+    def set_nameserver(domain, ip)
+      File.open("/tmp/#{domain}", 'w') { |file| file.write("nameserver #{ip}") }
+      adminrun("mkdir -p /etc/resolver;mv /tmp/#{domain} /etc/resolver/")
+    end
+
+    def unset_nameserver(domain, ip)
+      raise CFMicro::MCFError, "domain missing" unless domain
+      adminrun("rm -f /etc/resolver/#{domain}")
+    end
+  end
+
+end

data/lib/micro-cf-plugin/micro/switcher/dummy.rb

@@ -0,0 +1,15 @@
+# only used for testing
+module CFMicro::Switcher
+
+  class Dummy < Base
+    def adminrun(command)
+    end
+
+    def set_nameserver(domain, ip)
+    end
+
+    def unset_nameserver(domain, ip)
+    end
+  end
+
+end

data/lib/micro-cf-plugin/micro/switcher/linux.rb

@@ -0,0 +1,16 @@
+module CFMicro::Switcher
+
+  class Linux < Base
+    def set_nameserver(domain, ip)
+      CFMicro.run_command("sudo", "sed -i'.backup' '1 i nameserver #{ip}' /etc/resolv.conf")
+      # lock resolv.conf so Network Manager doesn't clear out the file when offline
+      CFMicro.run_command("sudo", "chattr +i /etc/resolv.conf")
+    end
+
+    def unset_nameserver(domain, ip)
+      CFMicro.run_command("sudo", "chattr -i /etc/resolv.conf")
+      CFMicro.run_command("sudo", "sed -i'.backup' '/#{ip}/d' /etc/resolv.conf")
+    end
+  end
+
+end

data/lib/micro-cf-plugin/micro/switcher/windows.rb

@@ -0,0 +1,31 @@
+module CFMicro::Switcher
+
+  class Windows < Base
+    def version
+      CFMicro.run_command("cmd", "/c ver").to_s.scan(/\d+\.\d+/).first.to_f
+    end
+
+    def adminrun(command, args=nil)
+      if version > 5.2
+        require 'win32ole'
+        shell = WIN32OLE.new("Shell.Application")
+        shell.ShellExecute(command, args, nil, "runas", 0)
+      else
+        # on older version this will try to run the command, and if you don't have
+        # admin privilges it will tell you so and exit
+        CFMicro.run_command(command, args)
+      end
+    end
+
+    # TODO better method to figure out the interface name is to get the NAT ip and find the
+    # interface with the correct subnet
+    def set_nameserver(domain, ip)
+      adminrun("netsh", "interface ip set dns \"VMware Network Adapter VMnet8\" static #{ip}")
+    end
+
+    def unset_nameserver(domain, ip)
+      adminrun("netsh", "interface ip set dns \"VMware Network Adapter VMnet8\" static none")
+    end
+  end
+
+end

data/lib/micro-cf-plugin/micro/vmrun.rb

@@ -0,0 +1,175 @@
+require "micro-cf-plugin/errors"
+
+module CFMicro
+  class VMrun
+    attr_reader :vmx, :vmrun
+
+    def initialize(config)
+      @platform = config[:platform]
+      @user = 'root' # must use root as we muck around with system settings
+      @password = config[:password]
+      @vmrun = config[:vmrun]
+      @vmx = config[:vmx]
+
+      # TODO honor TMPDIR
+      if @platform == :windows
+        @temp_dir = ENV['temp']
+      else
+        @temp_dir = '/tmp'
+      end
+    end
+
+    def vmx
+      @vmx
+    end
+
+    def connection_type
+      read_variable('ethernet0.connectionType')
+    end
+
+    def connection_type=(type)
+      write_variable("ethernet0.connectionType", type)
+    end
+
+    def nat?
+      connection_type == "nat"
+    end
+
+    def bridged?
+      connection_type == "bridged"
+    end
+
+    def domain
+      # switch to Dir.mktmpdir
+      state_config = CFMicro.escape_path(File.join(@temp_dir, 'state.yml'))
+      run('CopyFileFromGuestToHost', "/var/vcap/bosh/state.yml #{state_config}")
+      bosh_config = YAML.load_file(state_config)
+      bosh_config['properties']['domain']
+    end
+
+    def ip
+      # switch to Dir.mktmpdir
+      path = CFMicro.escape_path(CFMicro.config_file('refresh_ip.rb'))
+      ip_file = CFMicro.escape_path(File.join(@temp_dir, 'ip.txt'))
+      run('CopyFileFromHostToGuest', "#{path} /tmp/refresh_ip.rb")
+      run('runProgramInGuest', '/tmp/refresh_ip.rb')
+      run('CopyFileFromGuestToHost', "/tmp/ip.txt #{ip_file}")
+      File.open(ip_file, 'r') { |file| file.read }
+    end
+
+    def list
+      vms = run("list")
+      vms.delete_if { |line| line =~ /^Total/ }
+      vms.map { |line| CFMicro.escape_path(File.expand_path(line)) }
+    end
+
+    def offline?
+      command = "-gu #{@user} -gp #{@password} runProgramInGuest"
+      args =  '/usr/bin/test -e /var/vcap/micro/offline'
+      # why not use run_command?
+      result = %x{#{@vmrun} #{command} #{@vmx} #{args}}
+
+      if result.include?('Guest program exited with non-zero exit code: 1')
+        return false
+      elsif $?.exitstatus == 0
+        return true
+      else
+        raise CFMicro::MCFError, "failed to execute vmrun:\n#{result}"
+      end
+    end
+
+    def offline!
+      path = CFMicro.escape_path(CFMicro.config_file('offline.conf'))
+      run('CopyFileFromHostToGuest', "#{path} /etc/dnsmasq.d/offline.conf")
+      run('runProgramInGuest', '/usr/bin/touch /var/vcap/micro/offline')
+      run('runProgramInGuest',
+        "/bin/sed -i -e 's/^[^#]/# &/g' /etc/dnsmasq.d/server || true")
+      restart_dnsmasq
+    end
+
+    def online!
+      run('runProgramInGuest', '/bin/rm -f /etc/dnsmasq.d/offline.conf')
+      run('runProgramInGuest', '/bin/rm -f /var/vcap/micro/offline')
+      run('runProgramInGuest',
+        "/bin/sed -i -e 's/^# //g' /etc/dnsmasq.d/server || true")
+      restart_dnsmasq
+    end
+
+    # check to see if the micro cloud has been configured
+    # uses default password to check
+    def ready?
+      command = "-gu root -gp 'ca$hc0w' runProgramInGuest"
+      args =  '/usr/bin/test -e /var/vcap/micro/micro.json'
+      result = %x{#{@vmrun} #{command} #{@vmx} #{args}}
+
+      if result.include?('Invalid user name or password for the guest OS') || $?.exitstatus == 0
+        return true
+      elsif $?.exitstatus == 1
+        return false
+      else
+        raise CFMicro::MCFError, "failed to execute vmrun:\n#{result}"
+      end
+    end
+
+    def read_variable(var)
+      # TODO deal with non-ok return
+      run("readVariable", "runtimeConfig #{var}").first
+    end
+
+    def write_variable(var, value)
+      run('writeVariable', "runtimeConfig #{var} #{value}")
+    end
+
+    def reset
+      run('reset', 'soft')
+    end
+
+    def restart_dnsmasq
+      # restart command doesn't always work, start and stop seems to be more reliable
+      run('runProgramInGuest', '/etc/init.d/dnsmasq stop')
+      run('runProgramInGuest', '/etc/init.d/dnsmasq start')
+    end
+
+    def run(command, args=nil)
+      if command.include?('Guest')
+        command = "-gu #{@user} -gp #{@password} #{command}"
+      end
+      CFMicro.run_command(@vmrun, "#{command} #{@vmx} #{args}")
+    end
+
+    def running?
+      vms = list
+      if @platform == :windows
+        vms.any? { |x|
+          x.downcase == @vmx.downcase
+        }
+      else
+        # Handle vmx being in a symlinked dir.
+        real_path = nil
+        begin
+          real_path = File.realpath(@vmx)
+        rescue
+        end
+        vms.include?(@vmx) || (real_path && vms.include?(real_path))
+      end
+    end
+
+    def start!
+      run('start') unless running?
+    end
+
+    def stop!
+      run('stop') if running?
+    end
+
+    def self.locate(platform)
+      paths = YAML.load_file(CFMicro.config_file('paths.yml'))
+      vmrun_paths = paths[platform.to_s]['vmrun']
+      vmrun_exe = @platform == :windows ? 'vmrun.exe' : 'vmrun'
+      vmrun = CFMicro.locate_file(vmrun_exe, "VMware", vmrun_paths)
+      err "Unable to locate vmrun, please supply --vmrun option" unless vmrun
+      vmrun
+    end
+  end
+
+end

data/lib/micro-cf-plugin/plugin.rb

@@ -0,0 +1,203 @@
+require "yaml"
+require "multi_json"
+require "cf/cli"
+
+require "micro-cf-plugin/help"
+require "micro-cf-plugin/micro/micro"
+require "micro-cf-plugin/micro/vmrun"
+require "micro-cf-plugin/micro/switcher/base"
+require "micro-cf-plugin/micro/switcher/darwin"
+require "micro-cf-plugin/micro/switcher/linux"
+require "micro-cf-plugin/micro/switcher/windows"
+
+module CFMicro
+  class McfCommand < CF::CLI
+    MICRO_FILE = '~/.cf/micro.yml'
+
+    desc "Display Micro Cloud Foundry VM status"
+    group :micro
+    input :vmx, :argument => :required,
+      :desc => "Path to micro.vmx"
+    input :password, :argument => :optional,
+      :desc => "Cleartext password for guest VM vcap user"
+    def micro_status
+      mode = runner.offline? ? 'offline' : 'online'
+
+      line "Micro Cloud Foundry VM currently in #{b(mode)} mode"
+      # should the VMX path be unescaped?
+      line "VMX Path: #{c(runner.vmx, :good)}"
+      line "Domain: #{c(runner.domain, :good)}"
+      line "IP Address: #{c(runner.ip, :good)}"
+    end
+
+    desc "Micro Cloud Foundry offline mode"
+    group :micro
+    input :vmx, :argument => :required,
+      :desc => "Path to micro.vmx"
+    input :password, :argument => :optional,
+      :desc => "Cleartext password for guest VM vcap user"
+    def micro_offline
+      if !runner.nat?
+        if ask("Reconfigure MCF VM network to nat mode and reboot?", :default => true)
+          with_progress("Rebooting MCF VM") do
+            runner.reset_to_nat!
+          end
+        else
+          fail "Aborted"
+        end
+      end
+
+      with_progress("Setting MCF VM to offline mode") do
+        runner.offline!
+      end
+
+      with_progress("Setting host DNS server") do
+        runner.set_host_dns!
+      end
+    end
+
+    desc "Micro Cloud Foundry online mode"
+    group :micro
+    input :vmx, :argument => :required,
+      :desc => "Path to micro.vmx"
+    input :password, :argument => :optional,
+      :desc => "Cleartext password for guest VM vcap user"
+    def micro_online
+      runner
+      with_progress("Unsetting host DNS server") do
+        runner.unset_host_dns!
+      end
+
+      with_progress("Setting MCF VM to online mode") do
+        runner.online!
+      end
+    end
+
+    def runner
+      return @runner if @runner
+
+      config = build_config
+      @runner = switcher(config)
+      check_vm_running
+      store_config(config)
+
+      @runner
+    end
+
+    def check_vm_running
+      unless runner.running?
+        if ask("MCF VM is not running. Do you want to start it?", :default => true)
+          with_progress("Starting MCF VM") do
+            runner.start!
+          end
+        else
+          fail "MCF VM needs to be running."
+        end
+      end
+
+      unless runner.ready?
+        fail "MCF VM initial setup needs to be completed before using 'cf micro'"
+      end
+    end
+
+    def switcher(config)
+      case McfCommand.platform
+      when :darwin
+        CFMicro::Switcher::Darwin.new(config)
+      when :linux
+        CFMicro::Switcher::Linux.new(config)
+      when :windows
+        CFMicro::Switcher::Windows.new(config)
+      when :dummy # for testing only
+        CFMicro::Switcher::Dummy.new(config)
+      else
+        fail "unsupported platform: #{McfCommand.platform}"
+      end
+    end
+
+    # Returns the configuration needed to run the micro related subcommands.
+    # First loads saved config from file (if there is any), then overrides
+    # loaded values with command line arguments, and finally tries to guess
+    # in case neither was used:
+    #   vmx       location of micro.vmx file
+    #   vmrun     location of vmrun command
+    #   password  password for vcap user (in the guest vm)
+    #   platform  current platform
+    def build_config
+      conf = micro # returns {} if there isn't a saved config
+
+      override(conf, :vmx, true) do
+        locate_vmx(McfCommand.platform)
+      end
+
+      override(conf, :vmrun, true) do
+        CFMicro::VMrun.locate(McfCommand.platform)
+      end
+
+      override(conf, :password) do
+        ask("Please enter your MCF VM password (vcap user) password", :echo => "*")
+      end
+
+      conf[:platform] = McfCommand.platform
+
+      conf
+    end
+
+    # Save the cleartext password if --save is supplied.
+    # Note: it is due to vix we have to use a cleartext password :(
+    # Only if --password is used and not --save is the password deleted from the
+    # config file before it is stored to disk.
+    def store_config(config)
+      if input[:save]
+        warn("cleartext password saved in: #{MICRO_FILE}")
+      end
+
+      store_micro(config)
+    end
+
+    # override with command line arguments and yield the block in case the option isn't set
+    def override(config, option, escape=false, &blk)
+      # override if given on the command line
+      if opt = input[option]
+        opt = CFMicro.escape_path(opt) if escape
+        config[option] = opt
+      end
+      config[option] = yield unless config[option]
+    end
+
+    def locate_vmx(platform)
+      paths = YAML.load_file(CFMicro.config_file('paths.yml'))
+      vmx_paths = paths[platform.to_s]['vmx']
+      vmx = CFMicro.locate_file('micro.vmx', 'micro', vmx_paths)
+      fail "Unable to locate micro.vmx, please supply --vmx option" unless vmx
+      vmx
+    end
+
+    def self.platform
+      case RUBY_PLATFORM
+      when /darwin/  # x86_64-darwin11.2.0
+        :darwin
+      when /linux/   # x86_64-linux
+        :linux
+      when /mingw|mswin32|cygwin/ # i386-mingw32
+        :windows
+      else
+        RUBY_PLATFORM
+      end
+    end
+
+    def micro
+      micro_file = File.expand_path(MICRO_FILE)
+      return {} unless File.exists? micro_file
+      contents = File.read(micro_file).strip
+      MultiJson.load(contents)
+    end
+
+    def store_micro(micro)
+      micro_file = File.expand_path(MICRO_FILE)
+      File.open(micro_file, 'w') do |file|
+        file.write(MultiJson.dump(micro))
+      end
+    end
+  end
+end

data/lib/micro-cf-plugin/version.rb

@@ -0,0 +1,3 @@
+module CFMicro
+  VERSION = "0.1.0.rc1".freeze
+end

data/spec/plugin_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+require 'micro-cf-plugin/plugin'
+
+describe CFMicro::McfCommand do
+  describe 'micro_status' do
+    shared_examples 'micro common inputs' do
+      describe 'inputs' do
+        subject { command.inputs }
+        it { expect(subject[:vmx][:description]).to eq "Path to micro.vmx" }
+        it { expect(subject[:password][:description]).to eq "Cleartext password for guest VM vcap user" }
+      end
+
+      describe 'arguments' do
+        subject { command.arguments }
+
+        it 'has the correct argument order' do
+          should eq([
+            {:type => :required, :value => nil, :name => :vmx},
+            {:type => :optional, :value => nil, :name => :password}
+          ])
+        end
+      end
+    end
+
+    describe '#metadata' do
+      let(:command) { Mothership.commands[:micro_status] }
+
+      include_examples 'micro common inputs'
+
+      describe 'command' do
+        subject { command }
+
+        its(:description) { should eq "Display Micro Cloud Foundry VM status" }
+        it { expect(Mothership::Help.group(:micro)).to include(subject) }
+      end
+    end
+  end
+
+  describe '#micro_offline' do
+    describe 'metadata' do
+      let(:command) { Mothership.commands[:micro_offline] }
+
+      include_examples 'micro common inputs'
+
+      describe 'command' do
+        subject { command }
+
+        its(:description) { should eq "Micro Cloud Foundry offline mode" }
+        it { expect(Mothership::Help.group(:micro)).to include(subject) }
+      end
+    end
+  end
+
+  describe '#micro_online' do
+    describe 'metadata' do
+      let(:command) { Mothership.commands[:micro_online] }
+
+      include_examples 'micro common inputs'
+
+      describe 'command' do
+        subject { command }
+
+        its(:description) { should eq "Micro Cloud Foundry online mode" }
+        it { expect(Mothership::Help.group(:micro)).to include(subject) }
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+SPEC_ROOT = File.dirname(__FILE__).freeze
+
+require "rspec"
+require "cf"
+require "cfoundry"
+require "cfoundry/test_support"
+
+RSpec.configure do |c|
+  c.include Fake::FakeMethods
+  c.mock_with :rr
+end

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification 
+name: micro-cf-plugin
+version: !ruby/object:Gem::Version 
+  hash: 140091367
+  prerelease: 6
+  segments: 
+  - 0
+  - 1
+  - 0
+  - rc
+  - 1
+  version: 0.1.0.rc1
+platform: ruby
+authors: 
+- Alex Suraci
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-03-18 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 25
+        segments: 
+        - 0
+        - 9
+        version: "0.9"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 2
+        - 11
+        version: "2.11"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: webmock
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 29
+        segments: 
+        - 1
+        - 9
+        version: "1.9"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rr
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 1
+        - 0
+        version: "1.0"
+  type: :development
+  version_requirements: *id004
+description: 
+email: 
+- asuraci@vmware.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- lib/micro-cf-plugin/errors.rb
+- lib/micro-cf-plugin/help.rb
+- lib/micro-cf-plugin/micro/micro.rb
+- lib/micro-cf-plugin/micro/switcher/base.rb
+- lib/micro-cf-plugin/micro/switcher/darwin.rb
+- lib/micro-cf-plugin/micro/switcher/dummy.rb
+- lib/micro-cf-plugin/micro/switcher/linux.rb
+- lib/micro-cf-plugin/micro/switcher/windows.rb
+- lib/micro-cf-plugin/micro/vmrun.rb
+- lib/micro-cf-plugin/plugin.rb
+- lib/micro-cf-plugin/version.rb
+- config/offline.conf
+- config/paths.yml
+- config/refresh_ip.rb
+- spec/plugin_spec.rb
+- spec/spec_helper.rb
+homepage: http://cloudfoundry.com/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      hash: 25
+      segments: 
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
+requirements: []
+
+rubyforge_project: micro-cf-plugin
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Provides a fake tunnel command that tells you to install the real plugin.
+test_files: 
+- spec/plugin_spec.rb
+- spec/spec_helper.rb