cf 0.6.1.rc9 → 0.6.1.rc10

data/lib/cf.rb

@@ -6,3 +6,7 @@ command_files = "../cf/cli/{app,route,domain,organization,space,service,start,us
 Dir[File.expand_path(command_files, __FILE__)].each do |file|
   require file unless File.basename(file) == 'base.rb'
 end
+
+require "tunnel/plugin"
+require "console/plugin"
+require "manifests/plugin"

data/lib/cf/cli.rb

@@ -26,8 +26,11 @@ module CF
     option :help, :desc => "Show command usage", :alias => "-h",
       :default => false
 
-    option :proxy, :desc => "Run this command as another user (admin)", :alias => "-u",
-      :value => :email
+    option :http_proxy, :desc => "Connect though an http proxy server", :alias => "--http-proxy",
+      :value => :http_proxy
+
+    option :https_proxy, :desc => "Connect though an https proxy server", :alias => "--https-proxy",
+      :value => :https_proxy
 
     option :version, :desc => "Print version number", :alias => "-v",
       :default => false
@@ -380,9 +383,11 @@ module CF
       token = info[:token] && CFoundry::AuthToken.from_hash(info)
 
       fail "V1 targets are no longer supported." if info[:version] == 1
-      fail "User switching not implemented." if input[:proxy]
 
       @@client = CFoundry::V2::Client.new(target, token)
+
+      @@client.http_proxy = input[:http_proxy] || ENV['HTTP_PROXY'] || ENV['http_proxy']
+      @@client.https_proxy = input[:https_proxy] || ENV['HTTPS_PROXY'] || ENV['https_proxy']
       @@client.trace = input[:trace]
 
       uri = URI.parse(target)

data/lib/cf/version.rb

@@ -1,3 +1,3 @@
 module CF
-  VERSION = "0.6.1.rc9".freeze
+  VERSION = "0.6.1.rc10".freeze
 end

data/lib/console/README.md

@@ -0,0 +1,16 @@
+[![Build Status](https://travis-ci.org/cloudfoundry/console-cf-plugin.png)](https://travis-ci.org/cloudfoundry/console-cf-plugin)
+[![Gem Version](https://badge.fury.io/rb/console-cf-plugin.png)](http://badge.fury.io/rb/console-cf-plugin)
+
+## Console
+### Info
+This plugin lets you connect to a Cloud Foundry application via telnet.
+
+### Installation
+```
+gem install console-cf-plugin
+```
+
+### Usage
+```
+console APP          Open a console connected to your app
+```

data/lib/console/console.rb

@@ -0,0 +1,187 @@
+require "net/telnet"
+require "readline"
+
+require "tunnel/tunnel"
+
+class CFConsole < CFTunnel
+  def initialize(client, app, port = 10000)
+    @client = client
+    @app = app
+    @port = port
+  end
+
+  def get_connection_info(auth)
+    instances = @app.instances
+    if instances.empty?
+      raise "App has no running instances; try starting it."
+    end
+
+    unless console = instances[0].console
+      raise "App does not have console access; try restarting it."
+    end
+
+    { "hostname" => console[:ip],
+      "port" => console[:port]
+    }
+  end
+
+  def get_credentials
+    YAML.load(@app.file("app", "cf-rails-console", ".consoleaccess"))
+  end
+
+  def start_console
+    prompt = login
+
+    init_readline
+
+    run_console prompt
+  end
+
+  def login(auth = get_credentials)
+    if !auth["username"] || !auth["password"]
+      raise "Unable to verify console credentials."
+    end
+
+    @telnet = telnet_client
+
+    prompt = nil
+    err_msg = "Login attempt timed out."
+
+    5.times do
+      begin
+        results = @telnet.login(
+          "Name" => auth["username"],
+          "Password" => auth["password"])
+
+        lines = results.sub("Login: Password: ", "").split("\n")
+
+        last_line = lines.pop
+
+        if last_line =~ /[$%#>] \z/n
+          prompt = last_line
+        elsif last_line =~ /Login failed/
+          err_msg = last_line
+        end
+
+        break
+
+      rescue TimeoutError
+        sleep 1
+
+      rescue EOFError
+        # This may happen if we login right after app starts
+        close_console
+        sleep 5
+        @telnet = telnet_client
+      end
+    end
+
+    unless prompt
+      close_console
+      raise err_msg
+    end
+
+    prompt
+  end
+
+  private
+
+  def init_readline
+    if Readline.respond_to?("basic_word_break_characters=")
+      Readline.basic_word_break_characters= " \t\n`><=;|&{("
+    end
+
+    Readline.completion_append_character = nil
+
+    # Assumes that sending a String ending with tab will return a non-empty
+    # String of comma-separated completion options, terminated by a new line
+    # For example, "app.\t" might result in "to_s,nil?,etc\n"
+    Readline.completion_proc = proc do |s|
+      console_tab_completion_data(s)
+    end
+  end
+
+  def run_console(prompt)
+    prev = trap("INT")  { |x| exit_console; prev.call(x); exit }
+    prev = trap("TERM") { |x| exit_console; prev.call(x); exit }
+
+    loop do
+      cmd = readline_with_history(prompt)
+
+      if cmd == nil
+        exit_console
+        break
+      end
+
+      prompt = send_console_command_display_results(cmd, prompt)
+    end
+  end
+
+  def readline_with_history(prompt)
+    line = Readline::readline(prompt)
+
+    return if line == nil || line == 'quit' || line == 'exit'
+
+    if line !~ /^\s*$/ && Readline::HISTORY.to_a[-1] != line
+      Readline::HISTORY.push(line)
+    end
+
+    line
+  end
+
+  def send_console_command_display_results(cmd, prompt)
+    begin
+      lines = send_console_command cmd
+
+      # Assumes the last line is a prompt
+      prompt = lines.pop
+
+      lines.each do |line|
+        puts line if line != cmd
+      end
+
+    rescue TimeoutError
+      puts "Timed out sending command to server."
+
+    rescue EOFError
+      raise "The console connection has been terminated. Perhaps the app was stopped or deleted?"
+    end
+
+    prompt
+  end
+
+  def send_console_command(cmd)
+    results = @telnet.cmd(cmd)
+    results.split("\n")
+  end
+
+  def exit_console
+    @telnet.cmd("String" => "exit", "Timeout" => 1)
+  rescue TimeoutError
+    # TimeoutError expected, as exit doesn't return anything
+  ensure
+    close_console
+  end
+
+  def close_console
+    @telnet.close
+  end
+
+  def console_tab_completion_data(cmd)
+    begin
+      results = @telnet.
+          cmd("String" => cmd + "\t", "Match" => /\S*\n$/, "Timeout" => 10)
+      results.chomp.split(",")
+    rescue TimeoutError
+      [] #Just return empty results if timeout occurred on tab completion
+    end
+  end
+
+  def telnet_client
+    Net::Telnet.new(
+      "Port" => @port,
+      "Prompt" => /[$%#>] \z|Login failed/n,
+      "Timeout" => 30,
+      "FailEOF" => true)
+  end
+end

data/lib/console/plugin.rb

@@ -0,0 +1,30 @@
+require "cf/plugin"
+require "console/console"
+
+module CFConsolePlugin
+  class Console < CF::CLI
+    desc "Open a console connected to your app"
+    group :apps, :manage
+    input :app, :argument => :required, :from_given => by_name("app"),
+      :desc => "App to connect to"
+    input :port, :default => 10000
+    def console
+      app = input[:app]
+
+      console = CFConsole.new(client, app)
+      port = console.pick_port!(input[:port])
+
+      with_progress("Opening console on port #{c(port, :name)}") do
+        console.open!
+        console.wait_for_start
+      end
+
+      console.start_console
+    end
+
+    filter(:start, :start_app) do |app|
+      app.console = true
+      app
+    end
+  end
+end

data/lib/manifests/README.md

@@ -0,0 +1,13 @@
+[![Build Status](https://travis-ci.org/cloudfoundry/manifests-cf-plugin.png)](https://travis-ci.org/cloudfoundry/manifests-cf-plugin)
+[![Gem Version](https://badge.fury.io/rb/manifests-cf-plugin.png)](http://badge.fury.io/rb/manifests-cf-plugin)
+[![Code Climate](https://codeclimate.com/github/cloudfoundry/manifests-cf-plugin.png)](https://codeclimate.com/github/cloudfoundry/manifests-cf-plugin)
+
+## Manifests
+### Info
+With this plugin enabled, any configuration changes you make using the CF `start`, `restart`, `instances`, `logs`, `env`, `health`, `stats`, `scale`, and `app` commands will be saved to a file called *manifest.yml*.
+
+### Installation
+```
+gem install manifests-cf-plugin
+```
+

data/lib/manifests/errors.rb

@@ -0,0 +1,35 @@
+require "cf/errors"
+
+module CFManifests
+  class InvalidManifest < CF::UserFriendlyError
+    attr_reader :file
+
+    def initialize(file)
+      @file = file
+    end
+
+    def to_s
+      "Manifest file '#{@file}' is malformed."
+    end
+  end
+
+  class CircularDependency < CF::UserFriendlyError
+    def initialize(app)
+      @app = app
+    end
+
+    def to_s
+      "Circular dependency in application '#@app'"
+    end
+  end
+
+  class UnknownSymbol < CF::UserFriendlyError
+    def initialize(sym)
+      @sym = sym
+    end
+
+    def to_s
+      "Undefined symbol in manifest: '#@sym'"
+    end
+  end
+end

data/lib/manifests/loader.rb

@@ -0,0 +1,31 @@
+require "manifests/loader/builder"
+require "manifests/loader/normalizer"
+require "manifests/loader/resolver"
+
+module CFManifests
+  class Loader
+    include Builder
+    include Normalizer
+    include Resolver
+
+    def initialize(file, resolver)
+      @file = file
+      @resolver = resolver
+    end
+
+    def manifest
+      info = build(@file)
+      normalize! info
+      resolve info, @resolver
+    end
+
+    private
+
+    # expand a path relative to the manifest file's directory
+    def from_manifest(path)
+      return path unless @file
+
+      File.expand_path(path, File.dirname(@file))
+    end
+  end
+end

data/lib/manifests/loader/builder.rb

@@ -0,0 +1,39 @@
+require "manifests/errors"
+
+module CFManifests
+  module Builder
+    # parse a manifest and merge with its inherited manifests
+    def build(file)
+      manifest = YAML.load_file file
+      raise CFManifests::InvalidManifest.new(file) unless manifest
+
+      Array(manifest["inherit"]).each do |path|
+        manifest = merge_parent(path, manifest)
+      end
+
+      manifest.delete("inherit")
+
+      manifest
+    end
+
+    private
+
+    # merge the manifest at `parent_path' into the `child'
+    def merge_parent(parent_path, child)
+      merge_manifest(build(from_manifest(parent_path)), child)
+    end
+
+    # deep hash merge
+    def merge_manifest(parent, child)
+      merge = proc do |_, old, new|
+        if new.is_a?(Hash) && old.is_a?(Hash)
+          old.merge(new, &merge)
+        else
+          new
+        end
+      end
+
+      parent.merge(child, &merge)
+    end
+  end
+end

data/lib/manifests/loader/normalizer.rb

@@ -0,0 +1,145 @@
+module CFManifests
+  module Normalizer
+    MANIFEST_META = ["applications", "properties"]
+
+    def normalize!(manifest)
+      toplevel = toplevel_attributes(manifest)
+
+      apps = manifest["applications"]
+      apps ||= [{}]
+
+      default_paths_to_keys!(apps)
+
+      apps = convert_to_array(apps)
+
+      merge_toplevel!(toplevel, manifest, apps)
+      normalize_apps!(apps)
+
+      manifest["applications"] = apps
+
+      normalize_paths!(apps)
+
+      keyval = normalize_key_val(manifest)
+      manifest.clear.merge!(keyval)
+
+      nil
+    end
+
+    private
+
+    def normalize_paths!(apps)
+      apps.each do |app|
+        app["path"] = from_manifest(app["path"])
+      end
+    end
+
+    def convert_to_array(apps)
+      return apps if apps.is_a?(Array)
+
+      ordered_by_deps(apps)
+    end
+
+    # sort applications in dependency order
+    # e.g. if A depends on B, B will be listed before A
+    def ordered_by_deps(apps, processed = Set[])
+      ordered = []
+      apps.each do |tag, info|
+        next if processed.include?(tag)
+
+        if deps = Array(info["depends-on"])
+          dep_apps = {}
+          deps.each do |dep|
+            dep_apps[dep] = apps[dep]
+          end
+
+          processed.add(tag)
+
+          ordered += ordered_by_deps(dep_apps, processed)
+          ordered << info
+        else
+          ordered << info
+          processed.add(tag)
+        end
+      end
+
+      ordered.each { |app| app.delete("depends-on") }
+
+      ordered
+    end
+
+    def default_paths_to_keys!(apps)
+      return if apps.is_a?(Array)
+
+      apps.each do |tag, app|
+        app["path"] ||= tag
+      end
+    end
+
+    def normalize_apps!(apps)
+      apps.each do |app|
+        normalize_app!(app)
+      end
+    end
+
+    def merge_toplevel!(toplevel, manifest, apps)
+      return if toplevel.empty?
+
+      apps.collect! do |a|
+        toplevel.merge(a)
+      end
+
+      toplevel.each do |k, _|
+        manifest.delete k
+      end
+    end
+
+    def normalize_app!(app)
+      if app.key?("mem")
+        app["memory"] = app.delete("mem")
+      end
+
+      if app.key?("url") && app["url"].nil?
+        app["url"] = "none"
+      end
+
+      if app.key?("subdomain")
+        if app.key?("host")
+          app.delete("subdomain")
+        else
+          app["host"] = app.delete("subdomain")
+        end
+      end
+    end
+
+    def toplevel_attributes(manifest)
+      top =
+        manifest.reject { |k, _|
+          MANIFEST_META.include? k
+        }
+
+      # implicit toplevel path of .
+      top["path"] ||= "."
+
+      top
+    end
+
+    def normalize_key_val(val)
+      case val
+      when Hash
+        stringified = {}
+
+        val.each do |k, v|
+          stringified[k.to_sym] = normalize_key_val(v)
+        end
+
+        stringified
+      when Array
+        val.collect { |x| normalize_key_val(x) }
+      when nil
+        nil
+      else
+        val.to_s
+      end
+    end
+  end
+end