jdc 0.2.1 → 0.2.2.pre

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
 

data/lib/tunnel/plugin.rb

@@ -0,0 +1,183 @@
+require "jdc/cli"
+require "tunnel/tunnel"
+
+module JDCTunnelPlugin
+  class Tunnel < JDC::CLI
+    CLIENTS_FILE = "tunnel-clients.yml"
+    STOCK_CLIENTS = File.expand_path("../config/clients.yml", __FILE__)
+
+    desc "Create a local tunnel to a service."
+    group :services, :manage
+    input(:instance, :argument => :optional,
+          :from_given => find_by_name("service instance"),
+          :desc => "Service instance to tunnel to") { |instances|
+      ask("Which service instance?", :choices => instances,
+          :display => proc(&:name))
+    }
+    input(:client, :argument => :optional,
+          :desc => "Client to automatically launch") { |clients|
+      if clients.empty?
+        "none"
+      else
+        ask("Which client would you like to start?",
+            :choices => clients.keys.unshift("none"))
+      end
+    }
+    input(:port, :default => 10000, :desc => "Port to bind the tunnel to")
+    def tunnel
+      instances = client.service_instances
+      fail "No services available for tunneling." if instances.empty?
+
+      instance = input[:instance, instances.sort_by(&:name)]
+      vendor = instance.service_plan.service.label
+      clients = tunnel_clients[vendor] || {}
+      client_name = input[:client, clients]
+
+      tunnel = JDCTunnel.new(client, instance)
+      port = tunnel.pick_port!(input[:port])
+
+      conn_info =
+        with_progress("Opening tunnel on port #{c(port, :name)}") do
+          tunnel.open!
+        end
+
+      if client_name == "none"
+        unless quiet?
+          line
+          display_tunnel_connection_info(conn_info)
+
+          line
+          line "Open another shell to run command-line clients or"
+          line "use a UI tool to connect using the displayed information."
+          line "Press Ctrl-C to exit..."
+        end
+
+        tunnel.wait_for_end
+      else
+        with_progress("Waiting for local tunnel to become available") do
+          tunnel.wait_for_start
+        end
+
+        unless start_local_prog(clients, client_name, conn_info, port)
+          fail "'#{client_name}' execution failed; is it in your $PATH?"
+        end
+      end
+    end
+
+    def tunnel_clients
+      return @tunnel_clients if @tunnel_clients
+      stock_config = YAML.load_file(STOCK_CLIENTS)
+      custom_config_file = config_file_path
+
+      if File.exists?(custom_config_file)
+        custom_config = YAML.load_file(custom_config_file)
+        @tunnel_clients = deep_merge(stock_config, custom_config)
+      else
+        @tunnel_clients = stock_config
+      end
+    end
+
+    private
+
+    def config_file_path
+      File.expand_path("#{JDC::CONFIG_DIR}/.jdc/#{CLIENTS_FILE}")
+    end
+
+    def display_tunnel_connection_info(info)
+      line "Service connection info:"
+
+      to_show = [nil, nil, nil] # reserved for user, pass, db name
+      info.keys.each do |k|
+        case k
+        when "host", "hostname", "port", "node_id"
+          # skip
+        when "user", "username"
+          # prefer "username" over "user"
+          to_show[0] = k unless to_show[0] == "username"
+        when "password"
+          to_show[1] = k
+        when "name"
+          to_show[2] = k
+        else
+          to_show << k
+        end
+      end
+      to_show.compact!
+
+      align_len = to_show.collect(&:size).max + 1
+
+      indented do
+        to_show.each do |k|
+          # TODO: modify the server services rest call to have explicit knowledge
+          # about the items to return.  It should return all of them if
+          # the service is unknown so that we don't have to do this weird
+          # filtering.
+          line "#{k.ljust align_len}: #{b(info[k])}"
+        end
+      end
+
+      line
+    end
+
+    def start_local_prog(clients, command, info, port)
+      client = clients[File.basename(command)]
+
+      cmdline = "#{command} "
+
+      case client
+      when Hash
+        cmdline << resolve_symbols(client["command"], info, port)
+        client["environment"].each do |e|
+          if e =~ /([^=]+)=(["']?)([^"']*)\2/
+            ENV[$1] = resolve_symbols($3, info, port)
+          else
+            fail "Invalid environment variable: #{e}"
+          end
+        end
+      when String
+        cmdline << resolve_symbols(client, info, port)
+      else
+        raise "Unknown client info: #{client.inspect}."
+      end
+
+      if verbose?
+        line
+        line "Launching '#{cmdline}'"
+      end
+
+      system(cmdline)
+    end
+
+    def resolve_symbols(str, info, local_port)
+      str.gsub(/\$\{\s*([^\}]+)\s*\}/) do
+        sym = $1
+
+        case sym
+        when "host"
+          # TODO: determine proper host
+          "localhost"
+        when "port"
+          local_port
+        when "user", "username"
+          info["username"]
+        when /^ask (.+)/
+          ask($1)
+        else
+          info[sym] || raise("Unknown symbol in config: #{sym}")
+        end
+      end
+    end
+
+    def deep_merge(a, b)
+      merge = proc { |_, old, new|
+        if old.is_a?(Hash) && new.is_a?(Hash)
+          old.merge(new, &merge)
+        else
+          new
+        end
+      }
+
+      a.merge(b, &merge)
+    end
+  end
+end