cloulu 0.2.1 → 0.2.3

data/lib/mothership/help/commands.rb

@@ -29,13 +29,24 @@ class Mothership
   input :command, :argument => :optional
   input :all, :type => :boolean
   def help
+    platform_is_cross = (Object::RUBY_PLATFORM =~ /darwin/i) ? true : false
+    platform_is_windows = !platform_is_cross
+
+    if platform_is_windows
+      prefix = ""
+      suffix = ""
+    else
+      prefix = "\x1B[1m\x1B[33m"
+      suffix = "\x1B[00m"
+    end
+
     # custom header
-    puts "\x1B[1m\x1B[33m===========================================================\x1B[00m"
-    puts "\x1B[1m\x1B[33m* Welcome Cloulu Platform\x1B[00m"
-    puts "\x1B[1m\x1B[33m*\x1B[00m"
-    puts "\x1B[1m\x1B[33m* @author clouluteam <cloulu@sk.com>\x1B[00m"
-    puts "\x1B[1m\x1B[33m* @homepage https://cloulu.com, http://blog.cloulu.com\x1B[00m"
-    puts "\x1B[1m\x1B[33m============================================================\x1B[00m"
+    puts "#{prefix}===========================================================#{suffix}"
+    puts "#{prefix}* Welcome Cloulu PaaS Platform#{suffix}"
+    puts "#{prefix}*#{suffix}"
+    puts "#{prefix}* @author clouluteam <cloulu@sk.com>#{suffix}"
+    puts "#{prefix}* @homepage https://cloulu.com, https://github.com/cloulu#{suffix}"
+    puts "#{prefix}============================================================#{suffix}"
     puts
     
     if name = input[:command]

data/lib/mothership/help/printer.rb

@@ -23,16 +23,24 @@ module Mothership::Help
 
       i = "   " * indent
 
+      platform_is_cross = (Object::RUBY_PLATFORM =~ /darwin/i) ? true : false
+      platform_is_windows = !platform_is_cross
+
       # set prefix
       prefix = "*"
       prefix = ">>" if indent == 1
 
       # set color
-      color = "31"
-      color = "32" if indent == 1
-
       print i
-      puts "\x1B[1m\x1B[#{color}m" + prefix + " " + group[:description] + "\x1B[00m"
+      if platform_is_windows
+        puts prefix + " " + group[:description]
+      else
+        color = "31"
+        color = "32" if indent == 1
+
+        puts "\x1B[1m\x1B[#{color}m" + prefix + " " + group[:description] + "\x1B[00m"
+      end
+
 
       commands = unique_commands(commands)
 

data/lib/vmc/cli/app/files.rb

@@ -60,78 +60,5 @@ module VMC::App
     rescue CFoundry::FileError => e
       fail e.description
     end
-
-    desc "Stream an app's file contents"
-    group :apps, :info
-    input :app, :desc => "Application to inspect the files of",
-          :argument => true, :from_given => by_name(:app)
-    input :path, :desc => "Path of file to stream", :argument => :optional
-    def tail
-      app = input[:app]
-
-      lines = Queue.new
-      max_len = 0
-
-      if path = input[:path]
-        max_len = path.size
-        app.instances.each do |i|
-          Thread.new do
-            stream_path(lines, i, path.split("/"))
-          end
-        end
-      else
-        app.instances.each do |i|
-          i.files("logs").each do |path|
-            len = path.join("/").size
-            max_len = len if len > max_len
-
-            Thread.new do
-              stream_path(lines, i, path)
-            end
-          end
-        end
-      end
-
-      while line = lines.pop
-        instance, path, log = line
-
-        unless log.end_with?("\n")
-          log += i("%") if color?
-          log += "\n"
-        end
-
-        print "\##{c(instance.id, :instance)}  "
-        print "#{c(path.join("/").ljust(max_len), :name)}  "
-        print log
-      end
-    rescue CFoundry::NotFound
-      fail "Invalid path #{b(path)} for app #{b(app.name)}"
-    rescue CFoundry::FileError => e
-      fail e.description
-    end
-
-    def stream_path(lines, instance, path)
-      if verbose?
-        lines << [instance, path, c("streaming...", :good) + "\n"]
-      end
-
-      instance.stream_file(*path) do |contents|
-        contents.each_line do |line|
-          lines << [instance, path, line]
-        end
-      end
-
-      lines << [instance, path, c("end of file", :bad) + "\n"]
-    rescue Timeout::Error
-      if verbose?
-        lines << [
-          instance,
-          path,
-          c("timed out; reconnecting...", :bad) + "\n"
-        ]
-      end
-
-      retry
-    end
   end
 end

data/lib/vmc/cli/route/map.rb

@@ -10,71 +10,20 @@ module VMC::Route
     group :apps, :info
     input :app, :desc => "Application to add the URL to",
           :argument => :optional, :from_given => by_name(:app)
-    input :host, :desc => "Host name for the route",
-          :argument => :optional, :default => ""
     input :domain, :desc => "Domain to add the route to",
-          :argument => true,
-          :from_given => proc { |name, space|
-            if v2?
-              space.domain_by_name(name) ||
-                fail_unknown("domain", name)
-            else
-              name
-            end
-          }
+          :argument => true
     def map
       app = input[:app]
-      space = app.space if v2?
+      domain = input[:domain]
 
-      host = input[:host]
-      domain = input[:domain, space]
-
-      if v2?
-        route = find_or_create_route(domain, host, space)
-        bind_route(route, app) if app
-      else
-        with_progress("Updating #{c(app.name, :name)}") do
-          app.urls << domain
-          app.update!
-        end
+      with_progress("Updating #{c(app.name, :name)}") do
+        app.urls << domain
+        app.update!
       end
     end
 
     private
 
-    def bind_route(route, app)
-      with_progress("Binding #{c(route.name, :name)} to #{c(app.name, :name)}") do
-        app.add_route(route)
-      end
-    end
-
-    def find_or_create_route(domain, host, space)
-      find_route(domain, host) || create_route(domain, host, space)
-    end
-
-    def find_route(domain, host)
-      client.routes_by_host(host, :depth => 0).find { |r| r.domain == domain }
-    end
-
-    def create_route(domain, host, space)
-      route = client.route
-      route.host = host
-      route.domain = domain
-      route.space = space
-
-      with_progress("Creating route #{c(route.name, :name)}") do
-        route.create!
-      end
-
-      route
-    end
-
-    def find_domain(space, name)
-      domain = space.domain_by_name(name, :depth => 0)
-      fail "Invalid domain '#{name}'" unless domain
-      domain
-    end
-
     def ask_app
       ask("Which application?", :choices => client.apps, :display => proc(&:name))
     end

data/lib/vmc/version.rb

@@ -1,3 +1,3 @@
 module VMC
-  VERSION = "0.2.1".freeze
+  VERSION = "0.2.3".freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cloulu
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.3
   prerelease: 
 platform: ruby
 authors:
@@ -108,23 +108,7 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 0.2.2
-- !ruby/object:Gem::Dependency
-  name: rr
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.0'
-description: test
+description: cloulu client command line tool
 email:
 - cloulu@sk.com
 executables:
@@ -209,9 +193,6 @@ files:
 - lib/mothership/parser.rb
 - lib/mothership/version.rb
 - lib/mothership.rb
-- lib/tunnel-vmc-plugin/plugin.rb
-- lib/tunnel-vmc-plugin/tunnel.rb
-- lib/tunnel-vmc-plugin/version.rb
 - lib/uaa/http.rb
 - lib/uaa/misc.rb
 - lib/uaa/scim.rb

data/lib/tunnel-vmc-plugin/plugin.rb

@@ -1,178 +0,0 @@
-require "vmc/cli"
-require "tunnel-vmc-plugin/tunnel"
-
-module VMCTunnel
-  class Tunnel < VMC::CLI
-    CLIENTS_FILE = "#{VMC::CONFIG_DIR}/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 = v2? ? instance.service_plan.service.label : instance.vendor
-      clients = tunnel_clients[vendor] || {}
-      client_name = input[:client, clients]
-
-      tunnel = CFTunnel.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 = File.expand_path(CLIENTS_FILE)
-      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 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-vmc-plugin/tunnel.rb

@@ -1,308 +0,0 @@
-require "addressable/uri"
-require "restclient"
-require "uuidtools"
-
-require "caldecott-client"
-
-
-class CFTunnel
-  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)
-    target_base = @client.target.sub(/^[^\.]+\./, "")
-
-    url = "#{random_helper_url}.#{target_base}"
-    is_v2 = @client.is_a?(CFoundry::V2::Client)
-
-    app = @client.app
-    app.name = HELPER_NAME
-    app.framework = @client.framework_by_name("sinatra")
-    app.runtime = @client.runtime_by_name("ruby19")
-    app.command = "bundle exec ruby server.rb -p $VCAP_APP_PORT"
-    app.total_instances = 1
-    app.memory = 64
-    app.env = { "CALDECOTT_AUTH" => token }
-
-    if is_v2
-      app.space = @client.current_space
-    else
-      app.services = [@service] if @service
-      app.url = url
-    end
-
-    app.create!
-
-    if is_v2
-      app.bind(@service) if @service
-      app.create_route(url)
-    end
-
-    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?(CFoundry::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["VMC_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

data/lib/tunnel-vmc-plugin/version.rb

@@ -1,3 +0,0 @@
-module VMCTunnel
-  VERSION = "0.2.2".freeze
-end