vmc 0.3.23 → 0.4.0.beta.1

data/vmc-ng/Rakefile

@@ -0,0 +1,11 @@
+require "bundler"
+
+if Gem::Version.new(Bundler::VERSION) > Gem::Version.new("1.0.12")
+  require "bundler/gem_tasks"
+end
+
+task :default => :spec
+
+task :spec do
+
+end

data/vmc-ng/bin/vmc

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+# vim: ft=ruby
+
+require "rubygems"
+require "thor"
+
+require "vmc"
+require "vmc/plugin"
+
+VMC::Plugin.load_all
+
+$exit_status = 0
+VMC::CLI.start(ARGV)
+exit($exit_status)

data/vmc-ng/lib/vmc.rb

@@ -0,0 +1,2 @@
+require "vmc/version"
+require "vmc/cli"

data/vmc-ng/lib/vmc/cli.rb

@@ -0,0 +1,327 @@
+require "vmc/cli/command"
+
+VMC::Command.groups(
+  [:start, "Getting Started"],
+  [:apps, "Applications",
+    [:manage, "Management"],
+    [:info, "Information"]],
+  [:services, "Services",
+    [:manage, "Management"]],
+  [:admin, "Administration",
+    [:user, "User Management"]])
+
+require "vmc/cli/app"
+require "vmc/cli/service"
+require "vmc/cli/user"
+
+module VMC
+  class CLI < App # subclass App since we operate on Apps by default
+    desc "service SUBCOMMAND ...ARGS", "Service management"
+    subcommand "service", Service
+
+    desc "user SUBCOMMAND ...ARGS", "User management"
+    subcommand "user", User
+
+    desc "info", "Display information on the current target, user, etc."
+    group :start
+    flag :runtimes, :default => false
+    flag :services, :default => false
+    flag :frameworks, :default => false
+    def info
+      info =
+        with_progress("Getting target information") do
+          client.info
+        end
+
+      authorized = !!info["frameworks"]
+
+      if input(:runtimes)
+        raise NotAuthorized unless authorized
+
+        runtimes = {}
+        info["frameworks"].each do |_, f|
+          f["runtimes"].each do |r|
+            runtimes[r["name"]] = r
+          end
+        end
+
+        runtimes = runtimes.values.sort_by { |x| x["name"] }
+
+        if simple_output?
+          runtimes.each do |r|
+            puts r["name"]
+          end
+          return
+        end
+
+        runtimes.each do |r|
+          puts ""
+          puts "#{c(r["name"], :blue)}:"
+          puts "  version: #{b(r["version"])}"
+          puts "  description: #{b(r["description"])}"
+        end
+
+        return
+      end
+
+      if input(:services)
+        raise NotAuthorized unless authorized
+
+        services = {}
+        client.system_services.each do |_, svcs|
+          svcs.each do |name, versions|
+            services[name] = versions.values
+          end
+        end
+
+        if simple_output?
+          services.each do |name, _|
+            puts name
+          end
+
+          return
+        end
+
+        services.each do |name, versions|
+          puts ""
+          puts "#{c(name, :blue)}:"
+          puts "  versions: #{versions.collect { |v| v["version"] }.join ", "}"
+          puts "  description: #{versions[0]["description"]}"
+          puts "  type: #{versions[0]["type"]}"
+        end
+
+        return
+      end
+
+      if input(:frameworks)
+        raise NotAuthorized unless authorized
+
+        puts "" unless simple_output?
+
+        info["frameworks"].each do |name, _|
+          puts name
+        end
+
+        return
+      end
+
+      puts ""
+
+      puts info["description"]
+      puts ""
+      puts "target: #{b(client.target)}"
+      puts "  version: #{info["version"]}"
+      puts "  support: #{info["support"]}"
+
+      if info["user"]
+        puts ""
+        puts "user: #{b(info["user"])}"
+        puts "  usage:"
+
+        limits = info["limits"]
+        info["usage"].each do |k, v|
+          m = limits[k]
+          if k == "memory"
+            puts "    #{k}: #{usage(v * 1024 * 1024, m * 1024 * 1024)}"
+          else
+            puts "    #{k}: #{b(v)} of #{b(m)} limit"
+          end
+        end
+      end
+    end
+
+    desc "target [URL]", "Set or display the current target cloud"
+    group :start
+    def target(url = nil)
+      if url.nil?
+        display_target
+        return
+      end
+
+      target = sane_target_url(url)
+      display = c(target.sub(/https?:\/\//, ""), :blue)
+      with_progress("Setting target to #{display}") do
+        unless force?
+          # check that the target is valid
+          CFoundry::Client.new(target).info
+        end
+
+        set_target(target)
+      end
+    end
+
+    desc "login [EMAIL]", "Authenticate with the target"
+    group :start
+    flag(:email) {
+      ask("Email")
+    }
+    flag(:password)
+    # TODO: implement new authentication scheme
+    def login(email = nil)
+      unless simple_output?
+        display_target
+        puts ""
+      end
+
+      email ||= input(:email)
+      password = input(:password)
+
+      authenticated = false
+      failed = false
+      until authenticated
+        unless force?
+          if failed || !password
+            password = ask("Password", :echo => "*", :forget => true)
+          end
+        end
+
+        with_progress("Authenticating") do |s|
+          begin
+            save_token(client.login(email, password))
+            authenticated = true
+          rescue CFoundry::Denied
+            return if force?
+
+            s.fail do
+              failed = true
+            end
+          end
+        end
+      end
+    ensure
+      $exit_status = 1 if not authenticated
+    end
+
+    desc "logout", "Log out from the target"
+    group :start
+    def logout
+      with_progress("Logging out") do
+        remove_token
+      end
+    end
+
+    desc "register [EMAIL]", "Create a user and log in"
+    group :start, :hidden => true
+    flag(:email) {
+      ask("Email")
+    }
+    flag(:password) {
+      ask("Password", :echo => "*", :forget => true)
+    }
+    flag(:no_login, :type => :boolean)
+    def register(email = nil)
+      unless simple_output?
+        puts "Target: #{c(client_target, :blue)}"
+        puts ""
+      end
+
+      email ||= input(:email)
+      password = input(:password)
+
+      with_progress("Creating user") do
+        client.register(email, password)
+      end
+
+      unless input(:skip_login)
+        with_progress("Logging in") do
+          save_token(client.login(email, password))
+        end
+      end
+    end
+
+    desc "apps", "List your applications"
+    group :apps
+    def apps
+      apps =
+        with_progress("Getting applications") do
+          client.apps
+        end
+
+      if apps.empty? and !simple_output?
+        puts ""
+        puts "No applications."
+        return
+      end
+
+      apps.each.with_index do |a, num|
+        display_app(a)
+      end
+    end
+
+    desc "services", "List your services"
+    group :services
+    def services
+      services =
+        with_progress("Getting services") do
+          client.services
+        end
+
+      puts "" unless simple_output?
+
+      if services.empty? and !simple_output?
+        puts "No services."
+      end
+
+      services.each do |s|
+        display_service(s)
+      end
+    end
+
+    desc "users", "List all users"
+    group :admin, :hidden => true
+    def users
+      users =
+        with_progress("Getting users") do
+          client.users
+        end
+
+      users.each do |u|
+        display_user(u)
+      end
+    end
+
+    desc "help [COMMAND]", "usage instructions"
+    flag :all, :default => false
+    group :start
+    def help(task = nil)
+      if task
+        self.class.task_help(@shell, task)
+      else
+        unless input(:all)
+          puts "Showing basic command set. Pass --all to list all commands."
+          puts ""
+        end
+
+        self.class.print_help_groups(input(:all))
+      end
+    end
+
+    private
+
+    def display_service(s)
+      if simple_output?
+        puts s.name
+      else
+        puts "#{c(s.name, :blue)}: #{s.vendor} v#{s.version}"
+      end
+    end
+
+    def display_user(u)
+      if simple_output?
+        puts u.email
+      else
+        puts ""
+        puts "#{c(u.email, :blue)}:"
+        puts "  admin?: #{c(u.admin?, u.admin? ? :green : :red)}"
+      end
+    end
+
+    def display_target
+      if simple_output?
+        puts client.target
+      else
+        puts "Target: #{c(client.target, :blue)}"
+      end
+    end
+  end
+end

data/vmc-ng/lib/vmc/cli/app.rb

@@ -0,0 +1,622 @@
+require "vmc/cli/command"
+require "vmc/detect"
+
+module VMC
+  class App < Command
+    MEM_CHOICES = ["64M", "128M", "256M", "512M"]
+
+    desc "push [NAME]", "Push an application, syncing changes if it exists"
+    group :apps, :manage
+    flag(:name) { ask("Name") }
+    flag(:path) {
+      ask("Push from...", :default => ".")
+    }
+    flag(:url) { |name, target|
+      ask("URL", :default => "#{name}.#{target}")
+    }
+    flag(:memory) {
+      ask("Memory Limit",
+          :choices => MEM_CHOICES,
+
+          # TODO: base this on framework choice
+          :default => "64M")
+    }
+    flag(:instances) {
+      ask("Instances", :default => 1)
+    }
+    flag(:framework) { |choices, default|
+      ask("Framework", :choices => choices, :default => default)
+    }
+    flag(:runtime) { |choices|
+      ask("Runtime", :choices => choices)
+    }
+    flag(:start, :default => true)
+    flag(:restart, :default => true)
+    def push(name = nil)
+      path = File.expand_path(input(:path))
+
+      name ||= input(:name)
+
+      detector = Detector.new(client, path)
+      frameworks = detector.all_frameworks
+      detected, default = detector.frameworks
+
+      app = client.app(name)
+
+      if app.exists?
+        upload_app(app, path)
+        restart(app.name) if input(:restart)
+        return
+      end
+
+      app.total_instances = input(:instances)
+
+      domain = client.target.sub(/^https?:\/\/api\.(.+)\/?/, '\1')
+      app.urls = [input(:url, name, domain)]
+
+      framework = input(:framework, ["other"] + detected.keys, default)
+      if framework == "other"
+        forget(:framework)
+        framework = input(:framework, frameworks.keys)
+      end
+
+      framework_runtimes =
+        frameworks[framework]["runtimes"].collect do |k|
+          "#{k["name"]} (#{k["description"]})"
+        end
+
+      # TODO: include descriptions
+      runtime = input(:runtime, framework_runtimes).split.first
+
+      app.framework = framework
+      app.runtime = runtime
+
+      app.memory = megabytes(input(:memory))
+
+      with_progress("Creating #{c(name, :blue)}") do
+        app.create!
+      end
+
+      begin
+        upload_app(app, path)
+      rescue
+        err "Upload failed. Try again with 'vmc push'."
+        raise
+      end
+
+      start(name) if input(:start)
+    end
+
+    desc "start APPS...", "Start an application"
+    group :apps, :manage
+    flag :name
+    flag :debug_mode
+    def start(*names)
+      if name = input(:name)
+        names = [name]
+      end
+
+      fail "No applications given." if names.empty?
+
+      names.each do |name|
+        app = client.app(name)
+
+        fail "Unknown application." unless app.exists?
+
+        switch_mode(app, input(:debug_mode))
+
+        with_progress("Starting #{c(name, :blue)}") do |s|
+          if app.running?
+            s.skip do
+              err "Already started."
+            end
+          end
+
+          app.start!
+        end
+
+        check_application(app)
+
+        if app.debug_mode && !simple_output?
+          puts ""
+          instances(name)
+        end
+      end
+    end
+
+    desc "stop APPS...", "Stop an application"
+    group :apps, :manage
+    flag :name
+    def stop(*names)
+      if name = input(:name)
+        names = [name]
+      end
+
+      fail "No applications given." if names.empty?
+
+      names.each do |name|
+        with_progress("Stopping #{c(name, :blue)}") do |s|
+          app = client.app(name)
+
+          unless app.exists?
+            s.fail do
+              err "Unknown application."
+            end
+          end
+
+          if app.stopped?
+            s.skip do
+              err "Application is not running."
+            end
+          end
+
+          app.stop!
+        end
+      end
+    end
+
+    desc "restart APPS...", "Stop and start an application"
+    group :apps, :manage
+    flag :name
+    flag :debug_mode
+    def restart(*names)
+      stop(*names)
+      start(*names)
+    end
+
+    desc "delete APPS...", "Delete an application"
+    group :apps, :manage
+    flag :name
+    flag(:really) { |name, color|
+      force? || ask("Really delete #{c(name, color)}?", :default => false)
+    }
+    flag(:name) { |names|
+      ask("Delete which application?", :choices => names)
+    }
+    flag(:all, :default => false)
+    def delete(*names)
+      if input(:all)
+        return unless input(:really, "ALL APPS", :red)
+
+        with_progress("Deleting all applications") do
+          client.apps.collect(&:delete!)
+        end
+
+        return
+      end
+
+      if names.empty?
+        apps = client.apps
+        fail "No applications." if apps.empty?
+
+        names = [input(:name, apps.collect(&:name))]
+      end
+
+      names.each do |name|
+        really = input(:really, name, :blue)
+
+        forget(:really)
+
+        next unless really
+
+        with_progress("Deleting #{c(name, :blue)}") do
+          client.app(name).delete!
+        end
+      end
+    end
+
+    desc "instances APPS...", "List an app's instances"
+    group :apps, :info, :hidden => true
+    flag :name
+    def instances(*names)
+      if name = input(:name)
+        names = [name]
+      end
+
+      fail "No applications given." if names.empty?
+
+      names.each do |name|
+        instances =
+          with_progress("Getting instances for #{c(name, :blue)}") do
+            client.app(name).instances
+          end
+
+        instances.each do |i|
+          if simple_output?
+            puts i.index
+          else
+            puts ""
+            display_instance(i)
+          end
+        end
+      end
+    end
+
+    desc "scale APP", "Update the instances/memory limit for an application"
+    group :apps, :info, :hidden => true
+    flag(:instances, :type => :numeric) { |default|
+      ask("Instances", :default => default)
+    }
+    flag(:memory) { |default|
+      ask("Memory Limit",
+          :default => human_size(default * 1024 * 1024, 0),
+          :choices => MEM_CHOICES)
+    }
+    def scale(name)
+      app = client.app(name)
+
+      instances = passed_value(:instances)
+      memory = passed_value(:memory)
+
+      unless instances || memory
+        instances = input(:instances, app.total_instances)
+        memory = input(:memory, app.memory)
+      end
+
+      with_progress("Scaling #{c(name, :blue)}") do
+        app.total_instances = instances.to_i if instances
+        app.memory = megabytes(memory) if memory
+        app.update!
+      end
+    end
+
+    desc "logs APP", "Print out an app's logs"
+    group :apps, :info, :hidden => true
+    flag(:instance, :type => :numeric, :default => 0)
+    flag(:all, :default => false)
+    def logs(name)
+      app = client.app(name)
+      fail "Unknown application." unless app.exists?
+
+      instances =
+        if input(:all)
+          app.instances
+        else
+          app.instances.select { |i| i.index == input(:instance) }
+        end
+
+      if instances.empty?
+        if input(:all)
+          fail "No instances found."
+        else
+          fail "Instance #{name} \##{input(:instance)} not found."
+        end
+      end
+
+      instances.each do |i|
+        logs =
+          with_progress(
+            "Getting logs for " +
+              c(name, :blue) + " " +
+              c("\##{i.index}", :yellow)) do
+            i.files("logs")
+          end
+
+        puts "" unless simple_output?
+
+        logs.each do |log|
+          body =
+            with_progress("Reading " + b(log.join("/"))) do
+              i.file(*log)
+            end
+
+          puts body
+          puts "" unless body.empty?
+        end
+      end
+    end
+
+    desc "file APP [PATH]", "Print out an app's file contents"
+    group :apps, :info, :hidden => true
+    def file(name, path = "/")
+      file =
+        with_progress("Getting file contents") do
+          client.app(name).file(*path.split("/"))
+        end
+
+      puts "" unless simple_output?
+
+      print file
+    end
+
+    desc "files APP [PATH]", "Examine an app's files"
+    group :apps, :info, :hidden => true
+    def files(name, path = "/")
+      files =
+        with_progress("Getting file listing") do
+          client.app(name).files(*path.split("/"))
+        end
+
+      puts "" unless simple_output?
+
+      files.each do |file|
+        puts file
+      end
+    end
+
+    desc "health ...APPS", "Get application health"
+    group :apps, :info, :hidden => true
+    flag :name
+    def health(*names)
+      if name = input(:name)
+        names = [name]
+      end
+
+      apps =
+        with_progress("Getting application health") do
+          names.collect do |n|
+            [n, app_status(client.app(n))]
+          end
+        end
+
+      apps.each do |name, status|
+        unless simple_output?
+          puts ""
+          print "#{c(name, :blue)}: "
+        end
+
+        puts status
+      end
+    end
+
+    desc "stats APP", "Display application instance status"
+    group :apps, :info, :hidden => true
+    def stats(name)
+      stats =
+        with_progress("Getting stats") do
+          client.app(name).stats
+        end
+
+      stats.sort_by { |k, _| k }.each do |idx, info|
+        stats = info["stats"]
+        usage = stats["usage"]
+        puts ""
+        puts "instance #{c("#" + idx, :blue)}:"
+        print "  cpu: #{percentage(usage["cpu"])} of"
+        puts " #{b(stats["cores"])} cores"
+        puts "  memory: #{usage(usage["mem"] * 1024, stats["mem_quota"])}"
+        puts "  disk: #{usage(usage["disk"], stats["disk_quota"])}"
+      end
+    end
+
+    desc "update", "DEPRECATED", :hide => true
+    def update(*args)
+      fail "The 'update' command is no longer used; use 'push' instead."
+    end
+
+    class URL < Command
+      desc "map APP URL", "Add a URL mapping for an app"
+      group :apps, :info, :hidden => true
+      def map(name, url)
+        simple = url.sub(/^https?:\/\/(.*)\/?/i, '\1')
+
+        with_progress("Updating #{c(name, :blue)}") do
+          app = client.app(name)
+          app.urls << simple
+          app.update!
+        end
+      end
+
+      desc "unmap APP URL", "Remove a URL mapping from an app"
+      group :apps, :info, :hidden => true
+      def unmap(name, url)
+        simple = url.sub(/^https?:\/\/(.*)\/?/i, '\1')
+
+        app = client.app(name)
+        fail "Unknown application." unless app.exists?
+
+        with_progress("Updating #{c(name, :blue)}") do |s|
+          unless app.urls.delete(simple)
+            s.fail do
+              err "URL #{url} is not mapped to this application."
+              return
+            end
+          end
+
+          app.update!
+        end
+      end
+    end
+
+    desc "url SUBCOMMAND ...ARGS", "Manage application URL bindings"
+    subcommand "url", URL
+
+    class Env < Command
+      VALID_NAME = /^[a-zA-Za-z_][[:alnum:]_]*$/
+
+      desc "set APP [NAME] [VALUE]", "Set an environment variable"
+      group :apps, :info, :hidden => true
+      def set(appname, name, value)
+        unless name =~ VALID_NAME
+          fail "Invalid variable name; must match #{VALID_NAME.inspect}"
+        end
+
+        app = client.app(appname)
+        fail "Unknown application." unless app.exists?
+
+        with_progress("Updating #{c(app.name, :blue)}") do
+          app.update!("env" =>
+                        app.env.reject { |v|
+                          v.start_with?("#{name}=")
+                        }.push("#{name}=#{value}"))
+        end
+      end
+
+      desc "unset APP [NAME]", "Remove an environment variable"
+      group :apps, :info, :hidden => true
+      def unset(appname, name)
+        app = client.app(appname)
+        fail "Unknown application." unless app.exists?
+
+        with_progress("Updating #{c(app.name, :blue)}") do
+          app.update!("env" =>
+                        app.env.reject { |v|
+                          v.start_with?("#{name}=")
+                        })
+        end
+      end
+
+      desc "list APP", "Show all environment variables set for an app"
+      group :apps, :info, :hidden => true
+      def list(appname)
+        vars =
+          with_progress("Getting variables") do |s|
+            app = client.app(appname)
+
+            unless app.exists?
+              s.fail do
+                err "Unknown application."
+                return
+              end
+            end
+
+            app.env
+          end
+
+        puts "" unless simple_output?
+
+        vars.each do |pair|
+          name, val = pair.split("=", 2)
+          puts "#{c(name, :blue)}: #{val}"
+        end
+      end
+    end
+
+    desc "env SUBCOMMAND ...ARGS", "Manage application environment variables"
+    subcommand "env", Env
+
+    private
+
+    def upload_app(app, path)
+      with_progress("Uploading #{c(app.name, :blue)}") do
+        app.upload(path)
+      end
+    end
+
+    # set app debug mode, ensuring it's valid, and shutting it down
+    def switch_mode(app, mode)
+      mode = nil if mode == "none"
+
+      return false if app.debug_mode == mode
+
+      if mode.nil?
+        with_progress("Removing debug mode") do
+          app.debug_mode = nil
+          app.stop! if app.running?
+        end
+
+        return true
+      end
+
+      with_progress("Switching mode to #{c(mode, :blue)}") do |s|
+        runtimes = client.system_runtimes
+        modes = runtimes[app.runtime]["debug_modes"] || []
+        if modes.include?(mode)
+          app.debug_mode = mode
+          app.stop! if app.running?
+          true
+        else
+          s.fail do
+            err "Unknown mode '#{mode}'; available: #{modes.inspect}"
+            false
+          end
+        end
+      end
+    end
+
+    APP_CHECK_LIMIT = 60
+
+    def check_application(app)
+      with_progress("Checking #{c(app.name, :blue)}") do |s|
+        if app.debug_mode == "suspend"
+          s.skip do
+            puts "Application is in suspended debugging mode."
+            puts "It will wait for you to attach to it before starting."
+          end
+        end
+
+        seconds = 0
+        until app.healthy?
+          sleep 1
+          seconds += 1
+          if seconds == APP_CHECK_LIMIT
+            s.give_up do
+              err "Application failed to start."
+              # TODO: print logs
+            end
+          end
+        end
+      end
+    end
+
+    # choose the right color for app/instance state
+    def state_color(s)
+      case s
+      when "STARTING"
+        :blue
+      when "STARTED", "RUNNING"
+        :green
+      when "DOWN"
+        :red
+      when "FLAPPING"
+        :magenta
+      when "N/A"
+        :cyan
+      else
+        :yellow
+      end
+    end
+
+    def app_status(a)
+      health = a.health
+
+      if a.debug_mode == "suspend" && health == "0%"
+        c("suspended", :yellow)
+      else
+        c(health.downcase, state_color(health))
+      end
+    end
+
+    def display_app(a)
+      if simple_output?
+        puts a.name
+        return
+      end
+
+      puts ""
+
+      status = app_status(a)
+
+      print "#{c(a.name, :blue)}: #{status}"
+
+      unless a.total_instances == 1
+        print ", #{b(a.total_instances)} instances"
+      end
+
+      puts ""
+
+      unless a.urls.empty?
+        puts "  urls: #{a.urls.collect { |u| b(u) }.join(", ")}"
+      end
+
+      unless a.services.empty?
+        puts "  services: #{a.services.collect { |s| b(s) }.join(", ")}"
+      end
+    end
+
+    def display_instance(i)
+      print "instance #{c("\##{i.index}", :blue)}: "
+      puts "#{b(c(i.state.downcase, state_color(i.state)))} "
+
+      puts "  started: #{c(i.since.strftime("%F %r"), :cyan)}"
+
+      if d = i.debugger
+        puts "  debugger: port #{c(d["port"], :blue)} at #{c(d["ip"], :blue)}"
+      end
+
+      if c = i.console
+        puts "  console: port #{b(c["port"])} at #{b(c["ip"])}"
+      end
+    end
+  end
+end