jdc 0.1.2 → 0.2.0

data/lib/micro/plugin.rb

@@ -0,0 +1,197 @@
+require "yaml"
+require "multi_json"
+require "jdc/cli"
+require "micro/micro"
+require "micro/vmrun"
+require "micro/switcher/base"
+require "micro/switcher/darwin"
+require "micro/switcher/linux"
+require "micro/switcher/windows"
+
+module JDCMicro
+  class McfCommand < JDC::CLI
+    MICRO_FILE = '~/.jdc/micro.yml'
+
+    desc "Display Micro Cloud Foundry VM status"
+    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"
+      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"
+    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"
+    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 'jdc micro'"
+      end
+    end
+
+    def switcher(config)
+      case McfCommand.platform
+      when :darwin
+        JDCMicro::Switcher::Darwin.new(config)
+      when :linux
+        JDCMicro::Switcher::Linux.new(config)
+      when :windows
+        JDCMicro::Switcher::Windows.new(config)
+      when :dummy # for testing only
+        JDCMicro::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
+        JDCMicro::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 = JDCMicro.escape_path(opt) if escape
+        config[option] = opt
+      end
+      config[option] = yield unless config[option]
+    end
+
+    def locate_vmx(platform)
+      paths = YAML.load_file(JDCMicro.config_file('paths.yml'))
+      vmx_paths = paths[platform.to_s]['vmx']
+      vmx = JDCMicro.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/switcher/base.rb

@@ -0,0 +1,79 @@
+require "micro/errors"
+
+module JDCMicro::Switcher
+  class Base
+
+    def initialize(config)
+      @config = config
+
+      @vmrun = JDCMicro::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 JDCMicro::MCFError, "Micro Cloud Foundry VM already in offline mode"
+      else
+        @vmrun.offline!
+      end
+    end
+
+    def online!
+      if @vmrun.offline?
+        @vmrun.online!
+      else
+        raise JDCMirco::MCFError, "Micro Cloud Foundry already in online mode"
+      end
+    end
+  end
+end

data/lib/{jdc/micro → micro}/switcher/darwin.rb

@@ -1,8 +1,10 @@
-module JDC::Micro::Switcher
+require "micro/errors"
+
+module JDCMicro::Switcher
 
   class Darwin < Base
     def adminrun(command)
-      JDC::Micro.run_command("osascript", "-e 'do shell script \"#{command}\" with administrator privileges'")
+      JDCMicro.run_command("osascript", "-e 'do shell script \"#{command}\" with administrator privileges'")
     end
 
     def set_nameserver(domain, ip)
@@ -11,7 +13,7 @@ module JDC::Micro::Switcher
     end
 
     def unset_nameserver(domain, ip)
-      err "domain missing" unless domain
+      raise JDCMicro::MCFError, "domain missing" unless domain
       adminrun("rm -f /etc/resolver/#{domain}")
     end
   end

data/lib/{jdc/micro → micro}/switcher/dummy.rb

@@ -1,5 +1,5 @@
 # only used for testing
-module JDC::Micro::Switcher
+module JDCMicro::Switcher
 
   class Dummy < Base
     def adminrun(command)

data/lib/micro/switcher/linux.rb

@@ -0,0 +1,16 @@
+module JDCMicro::Switcher
+
+  class Linux < Base
+    def set_nameserver(domain, ip)
+      JDCMicro.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
+      JDCMicro.run_command("sudo", "chattr +i /etc/resolv.conf")
+    end
+
+    def unset_nameserver(domain, ip)
+      JDCMicro.run_command("sudo", "chattr -i /etc/resolv.conf")
+      JDCMicro.run_command("sudo", "sed -i'.backup' '/#{ip}/d' /etc/resolv.conf")
+    end
+  end
+
+end

data/lib/{jdc/micro → micro}/switcher/windows.rb

@@ -1,19 +1,19 @@
-module JDC::Micro::Switcher
+module JDCMicro::Switcher
 
   class Windows < Base
-    def version?
-      JDC::Micro.run_command("cmd", "/c ver").to_s.scan(/\d+\.\d+/).first.to_f
+    def version
+      JDCMicro.run_command("cmd", "/c ver").to_s.scan(/\d+\.\d+/).first.to_f
     end
 
     def adminrun(command, args=nil)
-      if version? > 5.2
+      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
-        JDC::Micro.run_command(command, args)
+        JDCMicro.run_command(command, args)
       end
     end
 

data/lib/{jdc/micro → micro}/vmrun.rb

@@ -1,13 +1,15 @@
-module JDC::Micro
+require "micro/errors"
+
+module JDCMicro
   class VMrun
     attr_reader :vmx, :vmrun
 
     def initialize(config)
-      @platform = config['platform']
+      @platform = config[:platform]
       @user = 'root' # must use root as we muck around with system settings
-      @password = config['password']
-      @vmrun = config['vmrun']
-      @vmx = config['vmx']
+      @password = config[:password]
+      @vmrun = config[:vmrun]
+      @vmx = config[:vmx]
 
       # TODO honor TMPDIR
       if @platform == :windows
@@ -17,6 +19,10 @@ module JDC::Micro
       end
     end
 
+    def vmx
+      @vmx
+    end
+
     def connection_type
       read_variable('ethernet0.connectionType')
     end
@@ -35,7 +41,7 @@ module JDC::Micro
 
     def domain
       # switch to Dir.mktmpdir
-      state_config = JDC::Micro.escape_path(File.join(@temp_dir, 'state.yml'))
+      state_config = JDCMicro.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']
@@ -43,8 +49,8 @@ module JDC::Micro
 
     def ip
       # switch to Dir.mktmpdir
-      path = JDC::Micro.escape_path(JDC::Micro.config_file('refresh_ip.rb'))
-      ip_file = JDC::Micro.escape_path(File.join(@temp_dir, 'ip.txt'))
+      path = JDCMicro.escape_path(JDCMicro.config_file('refresh_ip.rb'))
+      ip_file = JDCMicro.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}")
@@ -54,7 +60,7 @@ module JDC::Micro
     def list
       vms = run("list")
       vms.delete_if { |line| line =~ /^Total/ }
-      vms.map { |line| JDC::Micro.escape_path(File.expand_path(line)) }
+      vms.map { |line| JDCMicro.escape_path(File.expand_path(line)) }
     end
 
     def offline?
@@ -68,12 +74,12 @@ module JDC::Micro
       elsif $?.exitstatus == 0
         return true
       else
-        raise "failed to execute vmrun:\n#{result}"
+        raise JDCMicro::MCFError, "failed to execute vmrun:\n#{result}"
       end
     end
 
     def offline!
-      path = JDC::Micro.escape_path(JDC::Micro.config_file('offline.conf'))
+      path = JDCMicro.escape_path(JDCMicro.config_file('offline.conf'))
       run('CopyFileFromHostToGuest', "#{path} /etc/dnsmasq.d/offline.conf")
       run('runProgramInGuest', '/usr/bin/touch /var/vcap/micro/offline')
       run('runProgramInGuest',
@@ -101,7 +107,7 @@ module JDC::Micro
       elsif $?.exitstatus == 1
         return false
       else
-        raise "failed to execute vmrun:\n#{result}"
+        raise JDCMicro::MCFError, "failed to execute vmrun:\n#{result}"
       end
     end
 
@@ -128,14 +134,15 @@ module JDC::Micro
       if command.include?('Guest')
         command = "-gu #{@user} -gp #{@password} #{command}"
       end
-      JDC::Micro.run_command(@vmrun, "#{command} #{@vmx} #{args}")
+      JDCMicro.run_command(@vmrun, "#{command} #{@vmx} #{args}")
     end
 
     def running?
       vms = list
       if @platform == :windows
-        vms.map! { |x| x.downcase }
-        vms.include?(@vmx.downcase)
+        vms.any? { |x|
+          x.downcase == @vmx.downcase
+        }
       else
         # Handle vmx being in a symlinked dir.
         real_path = nil
@@ -147,19 +154,19 @@ module JDC::Micro
       end
     end
 
-    def start
+    def start!
       run('start') unless running?
     end
 
-    def stop
+    def stop!
       run('stop') if running?
     end
 
     def self.locate(platform)
-      paths = YAML.load_file(JDC::Micro.config_file('paths.yml'))
+      paths = YAML.load_file(JDCMicro.config_file('paths.yml'))
       vmrun_paths = paths[platform.to_s]['vmrun']
       vmrun_exe = @platform == :windows ? 'vmrun.exe' : 'vmrun'
-      vmrun = JDC::Micro.locate_file(vmrun_exe, "VMware", vmrun_paths)
+      vmrun = JDCMicro.locate_file(vmrun_exe, "VMware", vmrun_paths)
       err "Unable to locate vmrun, please supply --vmrun option" unless vmrun
       vmrun
     end

data/lib/tasks/gem_release.rake

@@ -0,0 +1,42 @@
+require 'active_support/core_ext'
+
+namespace :gem do
+  desc "Bump gem version, push to RubyGems, push to Github, add release notes"
+  task :release, [:version] do |_, args|
+    version = args[:version] || 'rc'
+    old_version = gem_version
+
+    sh! "gem bump --version #{version} --no-commit"
+    sh! "git add lib/jdc/version.rb"
+
+    print_with_purpose "Bumping to version #{gem_version}"
+    #generate_release_notes(old_version)
+    sh!("git commit -m 'Bumping to version #{gem_version}.'")
+    sh!("git push")
+    sh!("gem release --tag")
+  end
+
+  private
+  def generate_release_notes(old_version)
+    print_with_purpose "Generating release notes..."
+    file_name = "release_#{gem_version}"
+    sh!("anchorman notes --name=#{file_name} --from=v#{old_version}")
+    sh!("git add release_notes")
+  end
+
+  def sh!(cmd)
+    `#{cmd}`
+    raise "borked with #{$?}" unless $?.success?
+  end
+
+  def print_with_purpose(text)
+    puts "\033[34m#{text}\033[0m"
+  end
+
+  def gem_version
+    silence_warnings do
+      load "lib/jdc/version.rb"
+    end
+    Gem::Specification.load("jdc.gemspec").version.to_s
+  end
+end

data/lib/tunnel/README.md

@@ -0,0 +1,29 @@
+[![Build Status](https://travis-ci.org/cloudfoundry/tunnel-cf-plugin.png)](https://travis-ci.org/cloudfoundry/tunnel-cf-plugin)
+[![Gem Version](https://badge.fury.io/rb/tunnel-cf-plugin.png)](http://badge.fury.io/rb/tunnel-cf-plugin)
+
+## Tunnel
+### Info
+This plugin allows you to connect to a Cloud Foundry service using your own command line client. By default, the plugin supports *redis*, *mysql*, *mongodb*, and *postgresql*.
+
+### Installation
+```
+gem install tunnel-cf-plugin
+```
+
+### Usage
+```
+tunnel [INSTANCE] [CLIENT]        Create a local tunnel to a service.
+```
+
+You can add support for other command-line clients by providing a `~/.cf/clients.yml` file with the following format:
+
+```yaml
+service_name:
+  client_program_name: command line arguments
+  client_program_name_2:
+    command: command line arguments
+    environment:
+      - ENV_VAR_NAME=env_var_value
+```
+
+

data/{config → lib/tunnel/config}/clients.yml

@@ -3,12 +3,12 @@ redis:
 
 mysql:
   mysql: --protocol=TCP --host=${host} --port=${port} --user=${user} --password=${password} ${name}
-  mysqldump: --protocol=TCP --host=${host} --port=${port} --user=${user} --password=${password} ${name} > ${Output file}
+  mysqldump: --protocol=TCP --host=${host} --port=${port} --user=${user} --password=${password} ${name} > ${ask Output file}
 
 mongodb:
   mongo: --host ${host} --port ${port} -u ${user} -p ${password} ${name}
   mongodump: --host ${host} --port ${port} -u ${user} -p ${password} --db ${name}
-  mongorestore: --host ${host} --port ${port} -u ${user} -p ${password} --db ${name} ${Directory or filename to restore from}
+  mongorestore: --host ${host} --port ${port} -u ${user} -p ${password} --db ${name} ${ask Directory or filename to restore from}
 
 postgresql:
   psql:

data/lib/tunnel/helper-app/Gemfile

@@ -0,0 +1,10 @@
+source "http://rubygems.org"
+
+gem 'rack', '~> 1.2.0'
+gem 'caldecott', '= 0.0.3'
+gem 'bundler'
+gem 'em-websocket'
+gem 'async_sinatra'
+gem 'thin'
+gem 'json'
+gem 'uuidtools'

data/lib/tunnel/helper-app/Gemfile.lock

@@ -0,0 +1,48 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.2.6)
+    async_sinatra (0.5.0)
+      rack (>= 1.2.1)
+      sinatra (>= 1.0)
+    caldecott (0.0.3)
+      addressable (= 2.2.6)
+      async_sinatra (= 0.5.0)
+      em-http-request (= 0.3.0)
+      em-websocket (= 0.3.1)
+      json (= 1.6.1)
+      uuidtools (= 2.1.2)
+    daemons (1.1.8)
+    em-http-request (0.3.0)
+      addressable (>= 2.0.0)
+      escape_utils
+      eventmachine (>= 0.12.9)
+    em-websocket (0.3.1)
+      addressable (>= 2.1.1)
+      eventmachine (>= 0.12.9)
+    escape_utils (0.2.4)
+    eventmachine (0.12.10)
+    json (1.6.1)
+    rack (1.2.5)
+    sinatra (1.2.8)
+      rack (~> 1.1)
+      tilt (>= 1.2.2, < 2.0)
+    thin (1.4.1)
+      daemons (>= 1.0.9)
+      eventmachine (>= 0.12.6)
+      rack (>= 1.0.0)
+    tilt (1.3.3)
+    uuidtools (2.1.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  async_sinatra
+  bundler
+  caldecott (= 0.0.3)
+  em-websocket
+  json
+  rack (~> 1.2.0)
+  thin
+  uuidtools

data/{caldecott_helper → lib/tunnel/helper-app}/server.rb

@@ -10,7 +10,7 @@ require 'sinatra'
 require 'json'
 require 'eventmachine'
 
-port = ENV['JDC_APP_PORT']
+port = ENV['PORT']
 port ||= 8081
 
 # add vcap specific stuff to Caldecott
@@ -24,19 +24,19 @@ class VcapHttpTunnel < Caldecott::Server::HttpTunnel
   end
 
   get '/services' do
-    services_env = ENV['JDC_SERVICES']
+    services_env = ENV['VCAP_SERVICES']
     return "no services env" if services_env.nil? or services_env.empty?
     services_env
   end
 
   get '/services/:service' do |service_name|
-    services_env = ENV['JDC_SERVICES']
+    services_env = ENV['VCAP_SERVICES']
     not_found if services_env.nil?
 
-    services = JSON.parse(services_env)
+    services = JSON.parse(services_env).values.flatten(1)
     service = services.find { |s| s["name"] == service_name }
     not_found if service.nil?
-    service["options"].to_json
+    service["credentials"].to_json
   end
 end