jdc 0.2.1.pre → 0.2.1

data/lib/micro/switcher/base.rb

@@ -1,79 +0,0 @@
-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/micro/switcher/linux.rb

@@ -1,16 +0,0 @@
-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/tasks/gem_release.rake

@@ -1,42 +0,0 @@
-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

@@ -1,29 +0,0 @@
-[![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/lib/tunnel/helper-app/Gemfile

@@ -1,10 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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/lib/tunnel/plugin.rb

@@ -1,183 +0,0 @@
-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

data/lib/tunnel/tunnel.rb

@@ -1,295 +0,0 @@
-require "addressable/uri"
-require "restclient"
-require "uuidtools"
-
-require "caldecott-client"
-
-class JDCTunnel
-  HELPER_NAME = "caldecott"
-  HELPER_APP = File.expand_path("../helper-app", __FILE__)
-
-  # bump this AND the version info reported by HELPER_APP/server.rb
-  # this is to keep the helper in sync with any updates here
-  HELPER_VERSION = "0.0.4"
-
-  def initialize(client, service, port = 10000)
-    @client = client
-    @service = service
-    @port = port
-  end
-
-  def open!
-    if helper
-      auth = helper_auth
-
-      unless helper_healthy?(auth)
-        delete_helper
-        auth = create_helper
-      end
-    else
-      auth = create_helper
-    end
-
-    bind_to_helper if @service && !helper_already_binds?
-
-    info = get_connection_info(auth)
-
-    start_tunnel(info, auth)
-
-    info
-  end
-
-  def wait_for_start
-    10.times do |n|
-      begin
-        TCPSocket.open("localhost", @port).close
-        return true
-      rescue => e
-        sleep 1
-      end
-    end
-
-    raise "Could not connect to local tunnel."
-  end
-
-  def wait_for_end
-    if @local_tunnel_thread
-      @local_tunnel_thread.join
-    else
-      raise "Tunnel wasn't started!"
-    end
-  end
-
-  PORT_RANGE = 10
-  def pick_port!(port = @port)
-    original = port
-
-    PORT_RANGE.times do |n|
-      begin
-        TCPSocket.open("localhost", port)
-        port += 1
-      rescue
-        return @port = port
-      end
-    end
-
-    @port = grab_ephemeral_port
-  end
-
-  private
-
-  def helper
-    @helper ||= @client.app_by_name(HELPER_NAME)
-  end
-
-  def create_helper
-    auth = UUIDTools::UUID.random_create.to_s
-    push_helper(auth)
-    start_helper
-    auth
-  end
-
-  def helper_auth
-    helper.env["CALDECOTT_AUTH"]
-  end
-
-  def helper_healthy?(token)
-    return false unless helper.healthy?
-
-    begin
-      response = RestClient.get(
-        "#{helper_url}/info",
-        "Auth-Token" => token
-      )
-
-      info = JSON.parse(response)
-      if info["version"] == HELPER_VERSION
-        true
-      else
-        stop_helper
-        false
-      end
-    rescue RestClient::Exception
-      stop_helper
-      false
-    end
-  end
-
-  def helper_already_binds?
-    helper.binds? @service
-  end
-
-  def push_helper(token)
-    app = @client.app
-    app.name = HELPER_NAME
-    app.command = "bundle exec ruby server.rb"
-    app.total_instances = 1
-    app.memory = 128
-    app.env = {"CALDECOTT_AUTH" => token}
-
-    space = app.space = @client.current_space
-    app.create!
-
-    app.bind(@service) if @service
-
-    domain = @client.domains.find { |d| d.owning_organization == nil }
-
-    app.create_route(:domain => domain, :space => space, :host => random_helper_url)
-
-    begin
-      app.upload(HELPER_APP)
-      invalidate_tunnel_app_info
-    rescue
-      app.delete!
-      raise
-    end
-  end
-
-  def delete_helper
-    helper.delete!
-    invalidate_tunnel_app_info
-  end
-
-  def stop_helper
-    helper.stop!
-    invalidate_tunnel_app_info
-  end
-
-  TUNNEL_CHECK_LIMIT = 60
-  def start_helper
-    helper.start!
-
-    seconds = 0
-    until helper.healthy?
-      sleep 1
-      seconds += 1
-      if seconds == TUNNEL_CHECK_LIMIT
-        raise "Helper application failed to start."
-      end
-    end
-
-    invalidate_tunnel_app_info
-  end
-
-  def bind_to_helper
-    helper.bind(@service)
-    helper.restart!
-  end
-
-  def invalidate_tunnel_app_info
-    @helper_url = nil
-    @helper = nil
-  end
-
-  def helper_url
-    return @helper_url if @helper_url
-
-    tun_url = helper.url
-
-    ["https", "http"].each do |scheme|
-      url = "#{scheme}://#{tun_url}"
-      begin
-        RestClient.get(url)
-
-      # https failed
-      rescue Errno::ECONNREFUSED
-
-      # we expect a 404 since this request isn't auth'd
-      rescue RestClient::ResourceNotFound
-        return @helper_url = url
-      end
-    end
-
-    raise "Cannot determine URL for #{tun_url}"
-  end
-
-  def get_connection_info(token)
-    response = nil
-    10.times do
-      begin
-        response =
-          RestClient.get(
-            helper_url + "/" + safe_path("services", @service.name),
-            "Auth-Token" => token)
-
-        break
-      rescue RestClient::Exception => e
-        sleep 1
-      end
-    end
-
-    unless response
-      raise "Remote tunnel helper is unaware of #{@service.name}!"
-    end
-
-    is_v2 = @client.is_a?(JFoundry::V2::Client)
-
-    info = JSON.parse(response)
-    case (is_v2 ? @service.service_plan.service.label : @service.vendor)
-    when "rabbitmq"
-      uri = Addressable::URI.parse info["url"]
-      info["hostname"] = uri.host
-      info["port"] = uri.port
-      info["vhost"] = uri.path[1..-1]
-      info["user"] = uri.user
-      info["password"] = uri.password
-      info.delete "url"
-
-    # we use "db" as the "name" for mongo
-    # existing "name" is junk
-    when "mongodb"
-      info["name"] = info["db"]
-      info.delete "db"
-
-    # our "name" is irrelevant for redis
-    when "redis"
-      info.delete "name"
-
-    when "filesystem"
-      raise "Tunneling is not supported for this type of service"
-    end
-
-    ["hostname", "port", "password"].each do |k|
-      raise "Could not determine #{k} for #{@service.name}" if info[k].nil?
-    end
-
-    info
-  end
-
-  def start_tunnel(conn_info, auth)
-    @local_tunnel_thread = Thread.new do
-      Caldecott::Client.start({
-        :local_port => @port,
-        :tun_url => helper_url,
-        :dst_host => conn_info["hostname"],
-        :dst_port => conn_info["port"],
-        :log_file => STDOUT,
-        :log_level => ENV["JDC_TUNNEL_DEBUG"] || "ERROR",
-        :auth_token => auth,
-        :quiet => true
-      })
-    end
-
-    at_exit { @local_tunnel_thread.kill }
-  end
-
-  def random_helper_url
-    random = sprintf("%x", rand(1000000))
-    "caldecott-#{random}"
-  end
-
-  def safe_path(*segments)
-    segments.flatten.collect { |x|
-      URI.encode x.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]")
-    }.join("/")
-  end
-
-  def grab_ephemeral_port
-    socket = TCPServer.new("0.0.0.0", 0)
-    socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
-    Socket.do_not_reverse_lookup = true
-    socket.addr[1]
-  ensure
-    socket.close
-  end
-end