jdc 0.1.2 → 0.2.0

data/Rakefile

@@ -0,0 +1,13 @@
+require "rake"
+require "rspec/core/rake_task"
+Dir.glob("lib/tasks/**/*").sort.each { |ext| load(ext) }
+
+specfile, _ = Dir["*.gemspec"]
+SPEC = Gem::Specification.load(specfile)
+CURRENT_VERSION = SPEC.version.to_s.freeze
+
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec
+
+# looking for a way to push gems? check out the new frontend-release git repo!
+# git@github.com:pivotal-vmware/frontend-release.git

data/bin/jdc

@@ -1,6 +1,16 @@
 #!/usr/bin/env ruby
+# vim: ft=ruby
 
-require File.expand_path('../../lib/cli', __FILE__)
+require "rubygems"
 
-JDC::Cli::Runner.run(ARGV.dup)
+require "jdc"
+require "jdc/plugin"
 
+$stdout.sync = true
+
+JDC::Plugin.load_all
+if Gem::Version.new(RUBY_VERSION.dup) < Gem::Version.new("1.9.3")
+  warn "ERROR: \033[31mRuby version #{RUBY_VERSION} is not supported.\033[0m Please install 1.9.3 or later. (See http://docs.cloudfoundry.com/docs/common/install_ruby.html for more information)"
+  exit 1
+end
+JDC::CLI.start(ARGV)

data/lib/admin/README.md

@@ -0,0 +1,15 @@
+## Admin
+### Info
+This plugin allows you to make manual HTTP requests to the Jing Dong Foundry REST API.
+
+### Usage
+
+```
+curl MODE PATH HEADERS...                       Execute a raw request
+guid TYPE [NAME]                                Obtain guid of an object(s)
+set-quota [QUOTA_DEFINITION] [ORGANIZATION]     Change the quota definition for the given (or current) organization.
+service-auth-tokens                           	List service auth tokens
+create-service-auth-token [LABEL] [PROVIDER]  	Create a service auth token
+update-service-auth-token [SERVICE_AUTH_TOKEN]	Update a service auth token
+delete-service-auth-token [SERVICE_AUTH_TOKEN]	Delete a service auth token
+```

data/lib/admin/curl.rb

@@ -0,0 +1,60 @@
+require "multi_json"
+
+require "jdc/cli"
+=begin
+module JDCAdmin
+  class Curl < JDC::CLI
+    def precondition
+      check_target
+    end
+
+    desc "Execute a raw request"
+    group :admin
+    input :mode, :argument => :required, :desc => "Request mode (Get/Put/etc.)"
+    input :path, :argument => :required, :desc => "Request path"
+    input :headers, :argument => :splat, :desc => "Headers (i.e. Foo: bar)"
+    input :body, :alias => "-b", :desc => "Request body"
+    def curl
+      mode = input[:mode].upcase
+      path = input[:path]
+      body = input[:body]
+
+      headers = {}
+      input[:headers].each do |h|
+        k, v = h.split(/\s*:\s*/, 2)
+        headers[k.downcase] = v
+      end
+
+      content = headers["content-type"]
+      accept = headers["accept"]
+
+      content ||= :json if body
+      accept ||= :json unless %w(DELETE HEAD).include?(mode)
+
+      req, res =
+        client.base.rest_client.request(
+          mode,
+          remove_leading_slash(path),
+          :headers => headers,
+          :accept => accept,
+          :payload => body,
+          :content => body && content)
+
+      body = res[:body]
+
+      type = res[:headers]["content-type"]
+
+      if type && type.include?("application/json")
+        json = MultiJson.load(body)
+        puts MultiJson.dump(json, :pretty => true)
+      else
+        puts body
+      end
+    end
+
+    def remove_leading_slash(path)
+      path.sub(%r{^/}, '')
+    end
+  end
+end
+=end

data/lib/admin/guid.rb

@@ -0,0 +1,89 @@
+require "jdc/cli"
+
+module JDCAdmin
+  class Guid < JDC::CLI
+    def precondition
+      check_target
+    end
+
+    desc "Obtain guid of an object(s)"
+    group :admin
+    input :type, :argument => :required, :desc => "Object type (e.g. org, space, app, domain, ...)"
+    input :name, :argument => :optional, :desc => "Object name (e.g. some-app, ...)"
+    def guid
+      type = expand_type(input[:type])
+      name = input[:name]
+
+      _, res = client.base.rest_client.request("GET", api_path(type, name))
+
+      puts "Listing #{type} for '#{name}'...\n\n"
+      puts_response(res[:body])
+    end
+
+    private
+
+    def api_path(type, name)
+      "".tap do |url|
+        url << "v2/#{type}?"
+        url << "q=name:#{name}" if name
+      end
+    end
+
+    EXPANDED_TYPES = %w(
+      organizations
+      spaces
+      domains
+      routes
+      apps
+      services
+      service_instances
+      users
+    )
+
+    def expand_type(type)
+      EXPANDED_TYPES.detect do |expanded_type|
+        expanded_type.start_with?(type)
+      end || type
+    end
+
+    def puts_response(body)
+      # passing nil to load causes segfault
+      hash = MultiJson.load(body || "{}") rescue {}
+
+      puts_pagination(*hash.values_at("total_results", "total_pages"))
+      puts_resources(hash["resources"])
+    end
+
+    def puts_pagination(results, pages)
+      if results.nil?
+        puts "Unexpected response."
+      elsif results == 0
+        puts "No results."
+      else
+        puts "Found #{results} results on #{pages} pages. First page:"
+      end
+    end
+
+    def puts_resources(resources)
+      resources ||= []
+
+      sorted_resources = \
+        resources.sort_by { |r| [r["entity"]["name"].downcase] }
+
+      max_name_size = \
+        resources.map { |r| r["entity"]["name"].size }.max
+
+      sorted_resources.each_with_index do |resource, i|
+        puts_resource(resource, :max_name_size => max_name_size)
+        puts "---" if i % 3 == 2
+      end
+    end
+
+    def puts_resource(resource, opts={})
+      puts [
+        resource["entity"]["name"].ljust(opts[:max_name_size] + 2),
+        resource["metadata"]["guid"],
+      ].join
+    end
+  end
+end

data/lib/admin/plugin.rb

@@ -0,0 +1,6 @@
+require "admin/curl"
+require "admin/guid"
+require "admin/set_quota"
+#require "admin/service_auth_token"
+require "admin/service_broker/add"
+require "admin/service_broker/service_brokers"

data/lib/admin/service_auth_token.rb

@@ -0,0 +1,94 @@
+require "jdc/cli"
+
+module JDCAdmin
+  class ServiceAuthToken < JDC::CLI
+    def precondition
+      unless File.exists? target_file
+        fail "Please select a target with 'jdc target'."
+      end
+
+      #check_key
+      #unless client.logged_in?
+      #  fail "Please log in with 'jdc login'."
+      #end
+    end
+
+
+    desc "List service auth tokens"
+    group :admin
+    def service_auth_tokens
+      spaced(client.service_auth_tokens) do |t|
+        line "#{c(t.label, :name)}:"
+
+        indented do
+          line "guid: #{t.guid}"
+          line "provider: #{t.provider}"
+        end
+      end
+    end
+
+
+    desc "Create a service auth token"
+    group :admin
+    input(:label, :argument => :optional, :desc => "Auth token label") {
+      ask("Label")
+    }
+    input :provider, :argument => :optional, :default => "core",
+      :desc => "Auth token provider"
+    input(:token, :desc => "Auth token value") {
+      ask("Token")
+    }
+    def create_service_auth_token
+      sat = client.service_auth_token
+      sat.label = input[:label]
+      sat.provider = input[:provider]
+      sat.token = input[:token]
+
+      with_progress("Creating service auth token") do
+        sat.create!
+      end
+    end
+
+
+    desc "Update a service auth token"
+    group :admin
+    input(:service_auth_token, :argument => :optional,
+          :from_given => proc { |guid| client.service_auth_token(guid) },
+          :desc => "Auth token to delete") {
+      tokens = client.service_auth_tokens
+      fail "No tokens!" if tokens.empty?
+
+      ask("Which token?", :choices => tokens, :display => proc(&:label))
+    }
+    input(:token, :desc => "Auth token value") {
+      ask("Token")
+    }
+    def update_service_auth_token
+      sat = input[:service_auth_token]
+      sat.token = input[:token]
+
+      with_progress("Updating token #{c(sat.label, :name)}") do
+        sat.update!
+      end
+    end
+
+
+    desc "Delete a service auth token"
+    group :admin
+    input(:service_auth_token, :argument => :optional,
+          :from_given => proc { |guid| client.service_auth_token(guid) },
+          :desc => "Auth token to delete") {
+      tokens = client.service_auth_tokens
+      fail "No tokens!" if tokens.empty?
+
+      ask("Which token?", :choices => tokens, :display => proc(&:label))
+    }
+    def delete_service_auth_token
+      sat = input[:service_auth_token]
+
+      with_progress("Deleting token #{c(sat.label, :name)}") do
+        sat.delete!
+      end
+    end
+  end
+end

data/lib/admin/service_broker/add.rb

@@ -0,0 +1,47 @@
+require "jdc/cli"
+=begin
+module JDCAdmin::ServiceBroker
+  class Add < JDC::CLI
+    def precondition
+      check_target
+    end
+
+    desc "Add a Service Broker."
+    group :admin
+    input :name, :argument => :optional,
+      :desc => "Broker name"
+    input :url,
+      :desc => "Broker URL"
+    input :token,
+      :desc => "Broker token"
+
+    def add_service_broker
+      broker = client.service_broker
+
+      broker.name = input[:name]
+      finalize
+      broker.broker_url = input[:url]
+      finalize
+      broker.token = input[:token]
+      finalize
+
+      with_progress("") do
+        broker.create!
+      end
+    end
+
+    private
+    def ask_name
+      ask("Name")
+    end
+
+    def ask_url
+      ask("URL")
+    end
+
+    def ask_token
+      ask("Token")
+    end
+  end
+end
+=end

data/lib/admin/service_broker/service_brokers.rb

@@ -0,0 +1,24 @@
+require "jdc/cli"
+=begin
+module JDCAdmin::ServiceBroker
+  class ServiceBrokers < JDC::CLI
+    def precondition
+      check_target
+    end
+
+    desc "List Registered Service Brokers."
+    group :admin
+
+    def service_brokers
+      brokers = client.service_brokers
+      table(
+        %w(name url),
+        brokers.collect { |broker|
+          [c(broker.name, :name), broker.broker_url]
+        }
+      )
+    end
+
+  end
+end
+=end

data/lib/admin/set_quota.rb

@@ -0,0 +1,44 @@
+require "jdc/cli"
+
+module JDCAdmin
+  class SetQuota < JDC::CLI
+    def precondition
+      check_target
+    end
+
+    desc "Change the quota definition for the given (or current) organization."
+    group :admin
+    input :quota_definition, :argument => :optional,
+          :from_given => by_name(:quota_definition),
+          :desc => "Quota definition to set on the organization"
+    input :organization, :aliases => %w(org o), :argument => :optional,
+          :from_given => by_name(:organization),
+          :default => proc { client.current_organization || interact },
+          :desc => "Organization to update"
+    def set_quota
+      org = input[:organization]
+      quota = input[:quota_definition]
+
+      with_progress(<<MESSAGE.chomp) do
+Setting quota of #{c(org.name, :name)} to #{c(quota.name, :name)}
+MESSAGE
+        org.quota_definition = quota
+        org.update!
+      end
+    end
+
+    private
+
+    def ask_quota_definition
+      ask("Quota",
+          :choices => client.quota_definitions,
+          :display => proc(&:name))
+    end
+
+    def ask_organization
+      ask("Organization",
+          :choices => client.organizations,
+          :display => proc(&:name))
+    end
+  end
+end

data/lib/console/README.md

@@ -0,0 +1,8 @@
+## Console
+### Info
+This plugin lets you connect to a Jing Dong Foundry application via telnet.
+
+### 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 JDCConsole < JDCTunnel
+  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", "jdc-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.last != 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,33 @@
+require "jdc/plugin"
+require "console/console"
+=begin
+module JDCConsolePlugin
+  class Console < JDC::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 = JDCConsole.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
+
+    ::ManifestsPlugin.default_to_app_from_manifest :console, true
+
+    filter(:start, :start_app) do |app|
+      app.console = true
+      app
+    end
+  end
+end
+=end

data/lib/jdc/cli/app/app.rb

@@ -0,0 +1,43 @@
+require "jdc/cli/app/base"
+
+module JDC::App
+  class Apps < Base
+    IS_UTF8 = !!(ENV["LC_ALL"] || ENV["LC_CTYPE"] || ENV["LANG"] || "")["UTF-8"].freeze
+
+    desc "Show app information"
+    group :apps
+    input :app, :desc => "App to show", :argument => :required,
+          :from_given => by_name(:app)
+    def app
+      app = input[:app]
+
+      if quiet?
+        line app.name
+      else
+        display_app(app)
+      end
+    end
+
+    def display_app(a)
+      status = app_status(a)
+
+      line "#{c(a.name, :name)}: #{status}"
+
+      indented do
+        start_line "usage: #{b(human_mb(a.memory))}"
+        print " #{d(IS_UTF8 ? "\xc3\x97" : "x")} #{b(a.total_instances)}"
+        print " instance#{a.total_instances == 1 ? "" : "s"}"
+
+        line
+
+        unless a.urls.empty?
+          line "urls: #{a.urls.collect { |u| b(u) }.join(", ")}"
+        end
+
+        unless a.services.empty?
+          line "services: #{a.services.collect { |s| b(s.name) }.join(", ")}"
+        end
+      end
+    end
+  end
+end